Java学习线程

进程:进程指正在运行的进程。确切的来说,当一个进程进入内存运行,即变成一个进程,进程是处于运行过程中的进程,并且具有一定独立功能。

线程:线程是进程中的一个执行单元,负责当前进程中进程的执行,一个进程中至少有一个线程一个进程中是可以有多个线程,这个应用进程也可以称之为多线程进程。

单线程进程:若有多个任务,只能依次执行。当上一个任务执行完毕后,才能执行下一个任务。

多线程进程:若有多个任务可以同时执行。

package com.oracle.demo01;

public class Demo01 {
 /*普通main方法的执行就叫单线程
  * 单线程:只有一条路,后面的代码必须等着前面的代码执行完才能执行
  * main的名字就叫主线程 "main"
  * 
  * 在dos窗口,执行java.demo01
  * 启动JVM,运行demo01中的main方法
  * JVM运行main方法的时候,去找操作系统,开线程,开一条路径
  * 对于CPU来说,就有了一条执行路径
  * 
  * */
     public static void main(String[] args) {
  function();
  System.out.println(Math.abs(-9));
 }
     public static void function(){
      for(int i=0;i<10000;i++){
       System.out.println(i);
      }
     }
}

Thread类

构造方法:

常用方法:

Runnable接口

常用方法:

Thread类构造方法:

自定义线程的两种方式

1、将类声明为Thread类的子类,该子类应重写Thread类的run方法。

      创建对象,开启线程。run方法相当于其他线程的main方法。

2、声明一个实现Runnable接口的类,该类实现run方法。

   然后创建Runnable的子类对象,传入到某个线程的构造方法中开启线程

第一种方式:

1、 定义一个类继承Thread。

2 、重写run方法。

3 、创建子类对象,就是创建线程对象。

4 、调用start方法,开启线程并让线程执行,同时还会告诉jvm去调用run方法。

package com.oracle.demo01;

public class MyThread extends Thread {
 // 构造方法
 public MyThread() {
 }

 public MyThread(String name) {
  super(name);
 }

 @Override
 public void run() {
  Thread t = Thread.currentThread();
  String name = t.getName();// 获取当前正在执行的线程的名称
  for (int i = 0; i < 5; i++) {
   System.out.println(name + "正在运行" + i);
   try {
    t.sleep(100);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
 }
}
package com.oracle.demo01;

public class Demo02 {
 public static void main(String[] args) {
  //创建子类对象  就是创建线程对象
  MyThread mt = new MyThread();
     //启动线程(隐含运行run方法)
  mt.start();
  
  MyThread mt1 = new MyThread("小猪佩奇");
  //mt1.setName("小猪佩奇");  //设置自定义线程名称,但是主线程main不能改名称
  mt1.start();
     for(int i=0;i<5;i++){
      System.out.println("main方法"+i);
     }
 }
}

线程对象调用 run方法和调用start方法区别

线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程,并让jvm调用run方法在开启的线程中执行。

继承Thread类的原理

Thread t1 = new Thread();

t1.start();//这样做没有错,但是该start调用的是Thread类中的run方法,而这个run方法没有做什么事情,更重要的是这个run方法中并没有定义我们需要让线程执行的代码。

创建线程的目的:

是为了创建进程单独的执行路径,让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。

对于之前所讲的主线程,它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。

Threadrun方法中的任务并不是我们所需要的,只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置(run方法),那么只要在编写位置(run方法)中定义任务代码即可。所以进行了重写run方法动作。

第二种方式:

1、定义类实现Runnable接口。

2、覆盖接口中的run方法。。

3、创建Thread类的对象

4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

5、调用Thread类的start方法开启线程。

package com.oracle.demo01;

public class RunnableDemo implements Runnable{

 @Override
 public void run() {
  for(int i=0;i<5;i++){
   System.out.println("线程正在执行"+i);
  } 
 }
}

package com.oracle.demo01;

public class Test {
 public static void main(String[] args) {
        //创建Runnable的子类对象
 RunnableDemo rd=new RunnableDemo();
 //创建Thread类对象,并将Runnable的子类对象作为参数传递给Thread类的构造方法
         Thread t=new Thread(rd);
         t.start();
         for(int i=0;i<5;i++){
             System.out.println("主方法正在执行"+i);
         }
 }
}

实现Runnable的原理 

       实现Runnable接口避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法,将线程任务代码定义到run方法中。

    创建Thread类的对象只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中,而这个run方法所属于Runnable接口的子类对象,所以将这个子类对象作为参数传递给Thread的构造函数,这样,线程对象创建时就可以明确要运行的线程的任务。

实现Runnable的好处

    第二种方式实现Runnable接口避免了单继承的局限性,所以较为常用。实现Runnable接口的方式,更加的符合面向对象,线程分为两部分,一部分线程对象,一部分线程任务。继承Thread类,线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象,既是线程对象,又有线程任务。实现Runnable接口,将线程任务单独分离出来封装成对象,类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

获取线程名称

Thread.currentThread()获取当前线程对象

Thread.currentThread().getName();获取当前线程对象的名称

线程的匿名内部类

package com.oracle.demo01;
/*
 * 匿名内部类格式:
 * new 父类或接口{
 *    重写后的抽象方法
 * }.方法
 * new Thread(){
 *    public void run(){
 *    
 *    }
 * }.start();
 * */
public class Demo03 {
    public static void main(String[] args) {
  new Thread(){
   public void run(){
    System.out.println(super.getName()+"正在运行");
   }
  }.start();
  
  new Thread(new Runnable(){
   public void run(){
    System.out.println("Runnable正在运行");
   }
  }).start();
 }
}

线程的生命周期

线程最初被创建是新建状态,通过调用start()方法到达运行状态Runnable,当run()方法结束后,线程就到了死亡状态terminated
如果在调用start()方法时,CPU没有时间或者遇到同步锁,则线程达到受阻塞状态。当CPU有时间了,线程就会从受阻塞状态到达运行状态
最后到达死亡状态。
若在运行状态,别的线程抢走了CPU资源,则线程会处于受阻塞状态;若是调用了sleep()方法,线程就会处于休眠状态,当CPU有空了,线程会重新处于运行状态;
若是调用了wait()方法,则线程处于等待状态,当调用notify()方法时或者CPU有时间了,线程会从等待状态转为运行状态。
当线程处于休眠状态或者等待状态时,若是CPU没有时间,则线程都会处于受阻塞状态。
注:在受阻塞状态:线程具有cpu执行的资格,cpu有空就执行
在休眠状态或者等待状态,线程放弃CPU的执行资格,CPU有空了线程也不执行。

线程池

线程池,其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源

 线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程,线程创建的开销就被分摊到了多个任务上了,而且由于在请求到达时线程已经存在,所以消除了线程创建所带来的延迟。这样,就可以立即为请求服务,使用应用进程响应更快。另外,通过适当的调整线程中的线程数目可以防止出现资源不足的情况

使用线程池的方式—Runnable接口

线程池都是通过线程池工厂创建,再调用线程池中的方法获取线程,再通过线程去执行任务方法。

Executors:线程池创建工厂类

 public static ExecutorService newFixedThreadPool(int nThreads):返回线程池对象

 ExecutorService:线程池类

 Future<?> submit(Runnable task):获取线程池中的某一个线程对象,并执行

 Future接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用 

使用线程池中线程对象的步骤:

1、创建线程池对象

2、创建Runnable接口子类对象

3、提交Runnable接口子类对象

4、关闭线程池

package com.oracle.demo02;

public class RunnableImp implements Runnable{

 @Override
 public void run() {
  // TODO Auto-generated method stub
  for(int i=0;i<5;i++){
     System.out.println(Thread.currentThread().getName()+"线程"+i);
  }
 }

}
package com.oracle.demo02;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
 public static void main(String[] args) {
  //创建一个线程池对象,通过线程池工厂类调用newFixedThreadPool()
  //创建了盛有两个线程的线程池对象
  ExecutorService es = Executors.newFixedThreadPool(5);
  //获取线程池中某一线程对象,并执行
  es.submit(new RunnableImp());
  es.submit(new RunnableImp());
  es.submit(new RunnableImp());
                //关闭线程池
  es.shutdown();
 }
}

使用线程池方式-Callable接口

 Callable接口:与Runnable接口功能相似,用来指定线程的任务。其中的call()方法,用来返回线程任务执行完毕后的结果,call方法可抛出异常

 ExecutorService:线程池类

 <T> Future<T> submit(Callable<T> task):获取线程池中的某一个线程对象,并执行线程中的call()方法

 Future接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用 

 使用线程池中线程对象的步骤:

1、创建线程池对象

2、创建Callable接口子类对象

3、提交Callable接口子类对象

4、关闭线程池

package com.oracle.demo02;

import java.util.concurrent.Callable;

public class CallableImp implements Callable<String>{

 @Override
 public String call() throws Exception {
  // TODO Auto-generated method stub
  return "asd";
 }

}
package com.oracle.demo02;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test2 {
 public static void main(String[] args) throws InterruptedException, ExecutionException {
  // 创建线程池对象
  ExecutorService es = Executors.newFixedThreadPool(2);
  //获取线程池中的某一个线程对象,并执行线程中的call()方法
  //Future接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用
  Future<String> f = es.submit(new CallableImp());
                System.out.println(f.get());
 }
}

练习:计算1-100和1-200的总和

package com.oracle.demo02;

import java.util.concurrent.Callable;

public class CallableDemo implements Callable<Integer> {
 private int x;

 public CallableDemo(int x) {
  this.x = x;
 }

 public Integer call() throws Exception {
  int sum = 0;
  for (int i = 1; i <= x; i++) {
   sum = sum + i;
  }
  return sum;
 }

}
package com.oracle.demo02;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test3 {
 public static void main(String[] args) throws InterruptedException, ExecutionException {
  // 创建线程池对象
  ExecutorService es = Executors.newFixedThreadPool(2);
  Future<Integer> f = es.submit(new CallableDemo(100));
  Future<Integer> f2 = es.submit(new CallableDemo(200));
  System.out.println(f.get());
  System.out.println(f2.get());
  es.shutdown();
 }
}

  

关键词:线程 方法 对象 创建 执行 thread public run runnable nbsp

相关推荐:

java多线程系列:Executors框架

Java 线程详解(一)线程的基础

JAVA学习总结-多线程基础

Java-JUC(六):创建线程的4种方式

java多线程编程

Java多线程的应用场景和应用目的举例

java线程池

java多线程实现的三种方式

Java——线程的创建,线程池