线程Thread

---

一、概念

1、进程

• 进程就是正在运行中的程序

2、线程

• 是1个进程（程序内部）的1条执行路径
• 单线程：1个进程中只有1个线程（1条执行路径）
• 多线程：1个进程中包含多个线程（多条执行路径）
• 线程之间堆内存、方法区内存共享；但是栈内存独立，1个线程一个栈

3、CPU与线程的关系

1. 单核CPU：不能够做到真正的多线程并发，因为在一个时间单元内，只能执行一个线程的任务，多个线程谁获取时间片运行谁，每个线程获取时间片的概率相等，可能：t1、t2、t2、t2；给人一种多线程并发的感觉：其实是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是多个事情同时在做

4、并行、并发

1. 并行：多核CPU同时执行多个任务。比如：多个人同时做不同的事
2. 并发：单核CPU同时执行多个任务。比如：多个人做同一件事

5、线程的生命周期

1. 新建状态
   • 新建了线程对象，还没调用start方法
2. 就绪状态
   • 线程调用了start方法等待获取CPU时间片
   • 表示当前线程具有抢夺CPU时间片的权力
3. 运行状态
   • 线程对象开始执行run方法
   • run方法的开始执行标志着这个线程进入运行状态，当之前占有的CPU时间片用完之后，会重新回到就绪状态继续抢夺CPU时间片，当再次抢到CPU时间之后，会重新进入run方法接着上一次的代码继续往下执行
4. 阻塞状态
   • 当一个线程遇到阻塞事件，例如：sleep方法、获取synchronized排他锁失败(因为锁被其它线程所占用)等，此时线程会进入阻塞状态，阻塞状态的线程会放弃之前占有的CPU时间片，之前的时间片没了需要再次回到就绪状态抢夺CPU时间片
5. 死亡状态
   • run方法执行完毕或者因异常退出了run方法，该线程生命周期结束

二、创建

1、继承Thread

• class Thread implements Runnable
• 缺点：
  • 由于java是单继承的，这导致继承了Thread后就不能在继承其它类了；在实际开发中会经常继承某个超类来复用其中的方法，这导致两者不能同时继承
  • 继承线程后重写run方法来定义任务，这又导致我们将任务直接定义在线程上使得线程只能做该任务，无法并发执行其他任务，重用性变差

public class HandleMsg extends Thread{

    /** 线程标识 */
    private String threadKey;

    /** 构造方法用来区分不同线程便于测试 */
    public HandleMsg(String threadKey){
        this.threadKey=threadKey;
    }

    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.err.println(threadKey+"：run");
        }
    }

}

//匿名内部类lambda
Thread t1=new Thread(()->{
	for(int i=0;i<10;i++) {
		System.err.println("t1：run");
	}
};

//创建2个线程对象
HandleMsg h1=new HandleMsg("h1");
HandleMsg h2=new HandleMsg("h2");

//启动线程，开始执行实现的run方法
h1.start();
h2.start();

2、实现Runnable接口

• 优点：线程和线程执行的任务分离

public class HandleMsg implements Runnable{

    /** 线程标识 */
    private String threadKey;

    /** 构造方法用来区分不同线程便于测试 */
    public HandleMsg(String threadKey){
        this.threadKey=threadKey;
    }

    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.err.println(threadKey+"：run");
        }
    }

}

//创建2个任务对象
HandleMsg h1=new HandleMsg("h1");
HandleMsg h2=new HandleMsg("h2");

//将任务1交给线程1
Thread t1=new Thread(h1);
//将任务2交给线程2
Thread t2=new Thread(h2);

//启动线程，开始执行任务的run方法
t1.start();
t2.start();

3、实现Callable接口

• FutureTask implements RunnableFuture，RunnableFuture extends Runnable
• 优点
  • 线程和线程执行的任务分离
  • 有返回值
  • 可以声明抛出的异常

//Callable的泛型就是重写的call方法的返回值类型
public class HandleMsg implements Callable<String>{

    /** 线程标识 */
    private String threadKey;

    /** 构造方法用来区分不同线程便于测试 */
    public HandleMsg(String threadKey){
        this.threadKey=threadKey;
    }

    @Override
    public String call() throws Exception{
        for(int i=0;i<10;i++){
            System.err.println(threadKey+"：run");
        }
        return threadKey;
    }

}

//创建2个任务对象
HandleMsg h1=new HandleMsg("h1");
HandleMsg h2=new HandleMsg("h2");

//创建FutureTask类包装任务对象，泛型就是任务类实现Callable的泛型，也就是call方法返回值的类型
FutureTask<String> f1=new FutureTask<>(h1);
FutureTask<String> f2=new FutureTask<>(h2);

//将FutureTask对象交给线程
Thread t1=new Thread(f1);
Thread t2=new Thread(f2);

//启动线程，开始执行任务的run方法
t1.start();
t2.start();

//获取返回值
String result1=f1.get();
String result2=f2.get();

三、API

1、获取运行使用的线程

//在哪个方法执行就获取执行该方法的线程
Thread thread=Thread.currentThread();

2、唯一标识

long getId();

3、线程名

String getName();

//线程启动之前可以设置线程名
void setName(String name);

4、优先级

• 线程有10个优先级，用1-10表示，默认为5

int getPriority();

//启动之前设置
//线程无法主动获取cpu时间片，唯一可以干涉线程调度工作的方式就是修改线程的优先级，最大程度的改善获取cpu时间片的几率，理论上，线程优先级越高的线程获取cpu时间片的次数越多
void setPriority(int newPriority);

5、是否处于活动状态

boolean isAlive();

6、守护线程

• 守护线程又称为后台线程，默认创建出来的线程都是普通线程或称为前台线程
• 当进程结束时，所有正在运行的守护线程都会被强制中断
• 进程的结束：当一个进程中没有任何前台线程时即结束
• main主线程就是前台线程，不受其他线程影响，分配其他线程后接着干自己的事，其他线程执行的时候，main线程可能已经结束了

//是否为守护线程
boolean isDaemon();

//启动之前设置
void setDaemon(boolean on);

7、join

• 作用是：让当前执行的线程陷入等待（内部调用了wait方法）。
  • 永久等待：其实现原理是不停的检查当前线程是否存活，该线程的任务执行完毕后就会处于死亡状态，如果存活则说明任务还未执行完毕-继续等待
• 线程启动之后调用

1、API

//等待线程执行完任务后再往下执行，join(0);
void join();

//等待线程执行一段时间后再往下执行，无论线程任务是否执行完毕，单位：毫秒
//若指定的时间>线程任务执行时间，则线程任务执行完就会往下运行
//若指定的时间<线程任务执行时间，则达到指定时间就往下运行，线程任务继续执行，只是不再等待而已
void join(long millis);

2、有无join对比

//1、程序正常运行顺序是不会等待线程任务执行完毕，就会往下执行
Thread t1=new Thread(()->{
	for(int i=0;i<5;i++){
		System.err.println(i);
	}
});
t1.start();

System.err.println("next task");

// 输出结果
//		next task
//		0
//		1
//		2
//		3
//		4


//2、调用join
Thread t1=new Thread(()->{
	for(int i=0;i<5;i++){
		System.err.println(i);
	}
});
t1.start();

t1.join();

System.err.println("next task");

//		0
//		1
//		2
//		3
//		4
//		next task

8、yield

• 线程让步
• 暂停（不是终止）当前正在执行的线程任务，让其它具有相同优先级或更高优先级的等待的线程执行任务（其它也会包含暂停的线程，所以有可能刚暂停就执行）
• 暂停的线程状态变化：运行状态 -> 就绪状态
• 暂停期间不会释放锁，所以其他线程获取不到锁

9、sleep

• 使线程睡眠
• sleep的睡眠期间不会释放锁，所以其它线程获取不到锁
• 睡眠线程的状态变化：运行状态 -> 阻塞状态 -> 就绪状态

//Thread的静态方法，单位：毫秒
static void sleep(long millis) throws InterruptedException;

• sleep和wait的区别

sleep	wait
属于Thread类	属于Object类
可以在任何地方使用	wait、notify、notifyAll 只能在同步方法、同步控制块里面使用
睡眠期间不会释放锁	会释放锁，而且会将当前线程加入到等待队列中
不需要唤醒	可以被notify、notifyAll唤醒

10、线程中断

• 只是打断线程的睡眠，不会终止线程的继续执行

//线程是否中断
boolean isInterrupted();

//中断线程睡眠
Thread t1=new Thread(()->{
	System.err.println("run......");
	try{
		//睡眠10s
		Thread.sleep(10000L);
	}catch(InterruptedException e){
		e.printStackTrace();
	}
	System.err.println("end......");
});

//启动线程
t1.start();

//中断睡眠
//线程不会睡眠10s，而是被中断，抛出InterruptedException，捕获该异常后，继续执行后续的代码
t1.interrupt();

System.err.println("next task");

// 执行结果
//		next task
//		run......
//		end......