Java多线程之基础

1 并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生（同时发生）。

并发指的是在一段时间内宏观上有多个程序同时运行：

• 在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。
• 在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

2 线程与进程

程序：指令和数据的有序集合，本身没任何运行含义，是静态概念

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。（进入内存中运行的程序，叫进程）

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

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

线程调度:

• 分时调度

​ 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

• 抢占式调度

​ 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)；

​ Java使用的为抢占式调度。

多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程

main()线程称之为主线程，为系统的入口，用于执行整个程序

在一个进程中，如果开辟了多线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预

对同一份资源操作时，会出现资源抢夺问题，需加入并发控制

线程会带来额外的开销，如cpu调度时间，并发控制开销

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

3 线程

3.1 Thread类

Java使用java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

构造方法：

• public Thread() :分配一个新的线程对象。
• public Thread(String name) :分配一个指定名字的新的线程对象。
• public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
• public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

• public String getName() :获取当前线程名称。
• public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
• public void run() :此线程要执行的任务在此处定义代码。
• public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
• public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

主线程

JVM执行main方法，main方法会进入到栈内存，JVM会找操作系统开辟一条 main方法通向CPU的执行路径，CPU就可以通过这个路径来执行main方法，而此路径就称为main(主)线程。

• 普通方法调用和多线程调用

  

3.2 创建线程

3.2.1 方式一：继承Thread类

Java中通过继承Thread类来创建并启动多线程的步骤如下：

• 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
• 创建Thread子类的实例，即创建了线程对象
• 调用线程对象的start()方法来启动该线程
• 启动线程后，不一定立即执行，由cpu调度安排(主线程与thread线程，穿插进行)
• 子类继承Thread类具有多线程的能力(Thread类实现类Runnable接口)
• 启动线程：子类对象.start()
• 不建议使用：避免OOP单继承局限性

public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "正在执行！" + i);
        }
    }
}
public class DemoTest {
    public static void main(String[] args) {
        MyThread thread = new MyThread("新的线程");
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程" + i);
        }
    }
}

3.2.2 方式二：实现Runnable接口

实现java.lang.Runnable接口，重写run()方法。（Thread类也实现了Runnable接口）

步骤：

• 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
• 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
• 调用线程对象的start()方法来启动线程。
• 实现Runnable具有多线程能力
• 启动线程：传入目标对象+Thread对象.start()
• 推荐：避免单继承局限性，方便同一个对象被多个线程使用

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.print(Thread.currentThread().getName()+ " " + i + ",");
        }
    }
}
public class DemoTest {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread tr = new Thread(mr, "小强");
        Thread otr = new Thread(mr, "佩奇");
        tr.start();
        otr.start();
        for (int i = 0; i < 10; i++) {
            System.out.print("旺财" + i + ",");
        }
    }
}
/**
旺财0,旺财1,旺财2,旺财3,旺财4,旺财5,旺财6,旺财7,旺财8,旺财9,
佩奇 0,小强 0,佩奇 1,小强 1,佩奇 2,小强 2,佩奇 3,小强 3,佩奇 4,
小强 4,佩奇 5,小强 5,小强 6,小强 7,小强 8,小强 9,佩奇 6,佩奇 7,佩奇 8,佩奇 9,
*/

**所有的多线程代码都在run方法里面

tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

3.2.3 方式三：匿名内部类方式实现线程创建

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

public class NoNameInnerClassThread {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("xiaoqinag" + i);
                }
            }
        };
        new Thread(runnable).start();
        for (int i = 0; i < 20; i++) {
            System.out.println("daqiang:"+i);
        }
    }
}

3.2.4 方式四：Lambda方式实现线程创建

public class LambdaThread {
    public static void main(String[] args) {
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("xiaoqinag" + i);
            }
        }, "lambdaThread").start();

        for (int i = 0; i < 20; i++) {
            System.out.println("daqiang:"+i);
        }
    }
}

3.2.5 实现Callable接口

• 实现Callable接口
  • 1.实现Callable接口，需要返回值类型
  • 2.重写call方法,需要抛出异常
  • 3.创建目标对象t1
  • 4.创建执行服务: ExecutorService ser = Executors.newFixedThreadPool(1);
  • 5.提交执行: Future<Boolean> result1 = ser.submit(t1);
  • 6.获取结果: boolean r1 = result1.get()

3.2.6 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势：

• 适合多个相同的程序代码的线程去共享同一个资源。

• 可以避免java中的单继承的局限性。

• 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

  • 实现Runnable接口的方式，把设置线程任务和开启新线程进行分解（解耦）
  • 实现类中重写run方法：用来设置线程的任务；
  • 创建Thread类对象，调用start方法：用来开启新线程

• 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

3.3 多线程的原理

public class MyThread extends Thread{
    /*
* 利用继承中的特点
* 将线程名称传递 进行设置
*/
    public MyThread(String name){
        super(name);
    }
    /*
* 重写run方法
* 定义线程要执行的代码
*/
    public void run(){
        for (int i = 0; i < 20; i++) {
            //getName()方法 来自父亲
            System.out.println(getName()+i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        System.out.println("这里是main线程");
        MyThread mt = new MyThread("小强");
        mt.start();//开启了一个新的线程
        for (int i = 0; i < 20; i++) {
            System.out.println("旺财:"+i);
        }
    }
}   

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。2个线程抢占CPU的执行资源

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间

多个线程之间互不影响（在不同的栈空间）

3.4 守护(daemon)线程

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 用户线程结束，守护线程也会停止
• 用户线程变守护线程（setDaemon(true)，默认为false）

public class DaemonThread {
    public static void main(String[] args) {
        //守护线程
        Thread god = new Thread(() -> {
            while (true) {
                System.out.println(Thread.currentThread().getName() + ":god...always");
            }
        }, "God thread");
        god.setDaemon(true);
        god.start();
		//用户线程
        new Thread(() -> {
            for (int i = 0; i < 36500; i++) {
                System.out.println(Thread.currentThread().getName() + ":live" + i);
            }
            System.out.println("======GOODBYE WORLD=====");
        }, "You thread").start();
    }
}

4 线程安全

4.1 线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

/** 模拟多窗口买票 */
public class Ticket implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                try {//模拟出票
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
            }
        }
    }
}
public static void main(String[] args) {
    Ticket ticket = new Ticket();
    Thread t1 = new Thread(ticket, "窗口1");
    Thread t2 = new Thread(ticket, "窗口2");
    Thread t3 = new Thread(ticket, "窗口3");
    t1.start();
    t2.start();
    t3.start();
}
/**
...
窗口1正在卖：3
窗口2正在卖：2
窗口3正在卖：1
窗口1正在卖：0
窗口2正在卖：-1
*/

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

4.2 线程同步

当使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题，Java中提供了同步机制****(synchronized)来解决。

线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用

实现同步机制的三种方式：(同步条件：队列+锁)

• 同步代码块。
• 同步方法。
• 锁机制。

加锁后存在的问题：

• 一个线程持有锁会导致其他所有需要此锁的线程挂起
• 在多线程竞争下，加锁、释放锁，会导致比较多的上下文切换 和 调度延时，引起性能问题
• 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

4.2.1 同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式:

synchronized(同步锁Obj){
    //需要同步操作的代码
}

同步锁(同步监视器):

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

• 锁对象obj 可以是任意类型，推荐使用共享资源作为同步监视器。
• 多个线程对象 要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

public class Ticket implements Runnable {
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {//锁
                if (ticket > 0) {
                    try {//模拟出票
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
                }
            }
        }
    }
}

4.2.2 同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式

public synchronized void method(){
    //可能会产生线程安全问题的代码
}

同步锁是谁?

• 对于非static方法,同步锁就是this。
• 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

@Override
public void run() {
    while (true) {
        sellTicket();
    }
}
/**
 * 锁对象 是 谁调用这个方法 就是谁
 * 隐含 锁对象 就是 this
 */
private synchronized void sellTicket() {
    if (ticket > 0) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "正在卖：" + ticket--);
    }
}

4.2.3 锁机制Lock

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

• public void lock() :加同步锁。
• public void unlock() :释放同步锁。(放在finally中进行)

public class LockThread implements Runnable {
    Lock lock = new ReentrantLock();//ReentrantLock 实现了 Lock 接口
    @Override
    public void run() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

4.2.4 synchronize && lock

• Lock是显式锁(手动开启和关闭锁)，synchronize是隐式锁，出了作用域自动释放
• Lock只有代码块锁，synchronize有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性(提供更多子类)
• 优先使用顺序
  • Lock > 同步代码块(已进入方法体，分配了相应资源) > 同步方法(在方法体外)

5 线程状态

5.1 线程状态概述

在API中java.lang.Thread.State 这个枚举中给出了六种线程状态

线程状态	导致状态发生条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

Timed Waiting：A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.

• 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单线程也可以调用，不一定非要有协作关系。
• 为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样能保证该线程执行过程中会睡眠
• sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。

小提示：sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始立刻执行。

Blocked：A thread that is blocked waiting for a monitor lock is in this state.

• 受阻塞并且正在等待监视器锁的某一线程的线程状态。处于受阻塞状态的某一线程正在等待监视器锁，以便进入一个同步的块/方法；
• 线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

Waiting ： A thread that is waiting indefinitely for another thread to perform a particular action is in this state.

• 一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

public class WaitingDemo {
    public static Object obj = new Object();
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (obj) {
                        try {
                            System.out.println(Thread.currentThread().getName()
                                + "=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象");
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()
                                + "=== 从waiting状态醒来，获取到锁对象，继续执行了");
                    }
                }
            }
        },"等待线程").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        System.out.println(Thread.currentThread().getName()
                                + "------- 等待3秒钟");
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj) {
                        System.out.println(Thread.currentThread().getName()
                                + "------ 获取到锁对象，调用notify方法，释放锁对象");
                        obj.notify();
                    }
                }
            }
        },"唤醒线程").start();
    }
}
/**
等待线程=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象
唤醒线程------- 等待3秒钟
唤醒线程------ 获取到锁对象，调用notify方法，释放锁对象
唤醒线程------- 等待3秒钟
等待线程=== 从waiting状态醒来，获取到锁对象，继续执行了
等待线程=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象
唤醒线程------ 获取到锁对象，调用notify方法，释放锁对象
唤醒线程------- 等待3秒钟
等待线程=== 从waiting状态醒来，获取到锁对象，继续执行了
等待线程=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象
唤醒线程------ 获取到锁对象，调用notify方法，释放锁对象
唤醒线程------- 等待3秒钟
等待线程=== 从waiting状态醒来，获取到锁对象，继续执行了
等待线程=== 获取到锁对象，调用wait方法，进入waiting状态，释放锁对象
...
*/

• 一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的Object.notify()方法 或 Object.notifyAll()方法。其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系
• 当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。

线程个状态之间的转化：

public class StateThread {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("AAAAAAAAAAAAAAAAAA");
        });

        //NEW
        Thread.State state = thread.getState();
        System.out.println(state);
        thread.start();
        //RUNNABLE
        state = thread.getState();
        System.out.println(state);

        while (state != Thread.State.TERMINATED) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //TIMED_WAITING
            System.out.println(state);
            state = thread.getState();
        }
        //TERMINATED
        System.out.println(state);
    }
}

5.2 线程的停止

• 线程运行完后自己停止
• 使用标志位控制线程停止(推荐)
• 不推荐jdk提供的stop、destroy方法(已废弃)

public class StopThread implements Runnable {
    //标志位
    private boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            System.out.println("thread....run...");
        }
    }

    //对外提供改变标志位方法
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        StopThread target = new StopThread();
        new Thread(target).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main.....run..." + i);
            if (i == 988) {
                target.stop();
                System.out.println("thread....stop...");
            }
        }
    }
}

5.3 线程休眠

• sleep(时间) 指定当前线程阻塞的毫秒数
• sleep存在异常 InterruptException
• sleep时间到达后线程进入就绪状态
• sleep模拟网络延时(放大问题发生的可能性)、倒计时等
• 每一个对象都有一个锁，sleep不会释放锁

public class SleepThread implements Runnable {
    private int ticketNum = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                break;
            }
            try {
                //模拟网络延时
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNum-- + "张票");
        }
    }

    public static void main(String[] args) {
        TestTicketThread ticket = new TestTicketThread();
        new Thread(ticket, "AA").start();
        new Thread(ticket, "BB").start();
        new Thread(ticket, "CC").start();

        oneMinDown();
    }

    //倒计时
    public static void oneMinDown() {
        int num = 60;
        for (int i = num; i > 0; i--) {
            System.out.println(num--);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5.4 线程礼让

• 礼让线程yield，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让cpu重新调度，礼让不一定成功

public class YieldThread {
    public static void main(String[] args) {
        Runnable target = ()->{
            System.out.println(Thread.currentThread().getName()+"-->start");
            Thread.yield();
            System.out.println(Thread.currentThread().getName()+"-->end");
        };

        new Thread(target,"AA").start();
        new Thread(target,"BB").start();
    }
}
/*
礼让成功					 礼让失败
AA-->start					AA-->start
BB-->start					AA-->end
AA-->end					BB-->start
BB-->end					BB-->end
*/

5.5 线程强制执行

• join 合并线程，阻塞其他线程，待该线程执行完之后，再执行其他线程
• 类似插队

public class JoinThread {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("thread...."+i);
            }
        });
        thread.start();

        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                try {
                    //插队
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main...." + i);
        }
    }
}

5.6 线程优先级

• Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
• 线程优先级用数字表示，范围1~10
  • Thread.MIN_PRIORITY = 1;
  • Thread.MAX_PRIORITY = 10;
  • Thread.NORM_PRIORITY = 5;
• getPriority() 获取优先级
• setPriority(int xxx) 设置优先级 优先级的设置在start()之前
• 优先级高低意味着获得优先调度概率的高低，最终的调度还是看cpu

6 等待唤醒机制

6.1 线程间通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。

• 为何要处理线程之间的通讯？

​ 让多线程在访问同一份资源时按照一定的规律进行。

• 如何保证线程间通信有效利用资源：

​ 多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作，避免对同一共享变量的争夺————等待唤醒机制

6.2 等待唤醒机制

等待唤醒机制

• 是多个线程间的一种协作机制
• 在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。
• wait/notify 就是线程间的一种协作机制。

等待唤醒中的方法

• wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
• wait(long timeout)：等待指定的毫秒数
• notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位后，等候就餐最久的顾客最先入座。
• notifyAll：则释放所通知对象的 wait set 上的全部线程，优先级别高的线程优先调度。

注意：

哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。

总结如下：

• 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；
• 否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态

调用wait和notify方法需要注意的细节

• wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
• wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
• wait方法与notify方法必须要在同步代码块或者是同步函数中使用，否则会抛出异常IIlegalMonitorStateException。因为：必须要通过锁对象调用这2个方法。

6.3 生产者与消费者问题

等待唤醒机制其实就是经典的“生产者与消费者”的问题。

生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

• 对于生产者，没有生产产品之前，要通知消费者等待。而生产产品之后，又要马上通知消费者消费
• 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费

解决方法：线程同步+线程通讯

6.3.1 信号灯法（通过标志位）

• 包子铺线程生产包子，吃货线程消费包子。当包子没有时（包子状态为false），吃货线程等待，包子铺线程生产包子（即包子状态为true），并通知吃货线程（解除吃货的等待状态）,因为已经有包子了，那么包子铺线程进入等待状态。接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完（包子状态为false），并通知包子铺线程（解除包子铺的等待状态）,吃货线程进入等待。包子铺线程能否进一步执行则取决于锁的获取情况。

//资源
public class Baozi {
    private String pier;
    private String xianer;
    private boolean flag = false;//包子资源，是否存在
    public Baozi() {
    }
    public Baozi(String pier, String xianer) {
        this.pier = pier;
        this.xianer = xianer;
    }
    public String getPier() {
        return pier;
    }
    public void setPier(String pier) {
        this.pier = pier;
    }
    public String getXianer() {
        return xianer;
    }
    public void setXianer(String xianer) {
        this.xianer = xianer;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}
//消费者
public class ChiHuo extends Thread {
    private Baozi bz;
    public ChiHuo(String name, Baozi bz) {
        super(name);
        this.bz = bz;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (bz) {
                if (bz.isFlag() == false) {
                    try {
                        bz.wait();//吃货等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("吃货正在吃" + bz.getPier() + bz.getXianer() + "包子！");
                System.out.println("包子吃完了！");
                bz.setFlag(false);
                bz.notify();//唤醒包子铺
            }
        }
    }
}
//生产者
public class BaoZiPu extends Thread {
    private Baozi bz;
    public BaoZiPu(String name, Baozi bz) {
        super(name);
        this.bz = bz;
    }
    @Override
    public void run() {
        int count = 0;
        while (true) {
            synchronized (bz) {
                if (bz.isFlag()) {
                    try {
                        bz.wait();//包子铺停止生产
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("包子铺开始做包子");
                if (count % 2 == 0) {
                    bz.setPier("冰皮");
                    bz.setXianer("五仁");
                } else {
                    bz.setPier("薄皮");
                    bz.setXianer("牛肉大葱");
                }
                count++;
                bz.setFlag(true);
                System.out.println("包子造好了：" + bz.getPier() + bz.getXianer());
                System.out.println("吃货来吃包子吧");
                bz.notify();//唤醒吃货吃包子
            }
        }
    }
}
public class BaoZiTest {
    public static void main(String[] args) {
        Baozi bz = new Baozi();
        BaoZiPu bzp = new BaoZiPu("包子铺", bz);
        ChiHuo ch = new ChiHuo("吃货", bz);
        bzp.start();
        ch.start();
    }
}
/*
包子铺开始做包子
包子造好了：冰皮五仁
吃货来吃包子吧
吃货正在吃冰皮五仁包子！
包子吃完了！
包子铺开始做包子
包子造好了：薄皮牛肉大葱
吃货来吃包子吧
吃货正在吃薄皮牛肉大葱包子！
包子吃完了！
包子铺开始做包子
*/

6.3.2 管程法

• 生产者：负责生产数据的模块(可能是方法、对象、线程、进程)

• 消费者：负责处理数据的模块(可能是方法、对象、线程、进程)

• 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”，生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据

  

//生产者、消费者、产品、容器
public class PCThread {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Provider(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Provider extends Thread {
    SynContainer container;

    public Provider(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("生产者生产第" + i + "只鸡");
            container.push(new Chicken(i));
        }
    }
}

//消费者
class Consumer extends Thread {
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费者消费第" + container.pop().id + "只鸡");
        }

    }
}

//资源 鸡
class Chicken {
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区 容器
class SynContainer {
    //容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count;

    //生产者放入产品
    public synchronized void push(Chicken chicken) {
        //容器满了，生产者停止生产，等待消费者消费
        if (count == chickens.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //没满，则放入产品
        chickens[count] = chicken;
        count++;
        //通知消费者消费
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop() {
        //判断能否消费
        if (count == 0) {
            //消费者等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //可以消费
        count--;
        Chicken chicken = chickens[count];

        //吃完了通知生产者生产
        this.notifyAll();
        return chicken;
    }
 }

7 线程池

7.1 概述

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

• 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
• 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
• 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
  • corePoolSize：核心池的大小
  • maximumPoolSize：最大线程数
  • keepAliveTime：线程没有任务时最多保持多长时间后会终止

7.2 线程池的使用

• Java里面线程池的顶级接口是java.util.concurrent.Executor ，但是严格意义上讲Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService 。

• 在java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

  • public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

• 使用线程池对象

  • void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable

  • <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable

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

  • void shutdown()：关闭连接池

• 使用线程池中线程对象的步骤：

  • 创建线程池对象。
  • 创建Runnable接口子类对象。(task)
  • 提交Runnable接口子类对象。(take task)
  • 关闭线程池(一般不做)。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("教练来了： " + Thread.currentThread().getName());
        System.out.println("教我游泳,交完后，教练回到了游泳池");
    }
}
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        // 创建Runnable实例对象
        MyRunnable r = new MyRunnable();
        //自己创建线程对象的方式
        // Thread t = new Thread(r);
        // t.start(); ‐‐‐> 调用MyRunnable中的run()
        // 从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(r);
        // 再获取个线程对象，调用MyRunnable中的run()
        service.submit(r);
        service.submit(r);
        // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
        // 将使用完的线程又归还到了线程池中
        // 关闭线程池
        //service.shutdown();
    }
}