线程是进程的进一步细化，是一个程序内部的一条执行路径（程序中的每一个运行的功能、Java中的main方法执行）。
如果一个进程可以并行多个线程，则该进程为一个多线程进程（360是一个多线程进程，可以同时杀毒与清理垃圾，占用cpu和内存也会增加）。
线程作为调度和执行的单位，每一个线程拥有独立的运行栈（本地方法栈和虚拟机栈）和程序计算器，线程切换开销小。
一个进程中多个线程共享相同的内存单位/内存地址空间（JVM中的方法区和堆是线程共享的。他们从同一堆中分配对象，可以访问相同的变量和对象，使得线程之间通讯更加简便、高效、但多个线程操作共享的资源可能会带来安全隐患,可以参考下面的支付问题。

进程与线程关系

单核CPU和多核CPU的理解

cpu一个核心只能处理一个线程，分配给每个线程执行一段时间后挂起，再给另一个线程执行一段时间，但是因为CPU时间单元特别短，处理非常快，因此感觉不出多线程和单线程的区别
如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
一个java.exe应用程序中,会有至少三个线程:主线程main()、垃圾回收线程gc()——(主线程的守护线程,既与主线程同生共死。主线程在运行时，一些对象已经过期并且不再使用时，就由垃圾回收机制线程来回收,下面的"线程分类"有补充)、异常线程——（如果发生异常不处理就会影响主线程执行）

并行与并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片，快速切换线程)短时间内轮流执行多个任务。比如：秒杀、多个人做同一件事

使用多线程的优点

以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，减少CPU切换。但仍然需要多线程，因为多线程的优点是

提高应用程序的响应。对图形化界面更有意义，可增强用户体验。（用户不用等待一个东西处理完才进行下一步操作，而是可以边处理这个，还可以处理另外一个。不管效率怎么样，我只要用户体验度增加）
提高计算机系统CPU的利用率（因为现在计算机cpu并不是单核的）
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改（每个模块独立运行）

何时需要多线程

程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序时。

线程的创建和使用

线程的创建和启动

Java语言的JVM允许程序同时运行多个线程，它通过java.lang.Thread类来体现。
Thread类的特性
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体（一个线程对应一个Thread类型对象）
- 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

Thread类常用的方法

Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：指定创建线程的目标对象，它实现了Runnable接口中的run方法，并设置线程名称
start():启动当前线程对象的线程，执行当前线程的run()
run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread(): 静态方法，可以获取当前线程的引用.或者信息类,似toString.
- 格式:“Thread[main,5,main]:表示当前线程的名字为main,优先级为5,当前线程的主线程为main”
getName():获取当前线程的名字
setName():设置当前线程的名字,也可以写含参构造器(String name)来为其设置线程名
yield():就放弃当前线程掌握的cpu,并重新进入就绪状态与别的线程抢夺cpu资源,以获取cpu时间片
join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。也就是说这个方法用来在别的线程执行过程让cpu给指定线程,并进入阻塞状态,直至指定线程运行完毕后才结束阻塞
stop():。当执行此方法时，强制结束当前线程。已过时不推荐使用这种方式结束线程
sleep(long millitime)：让当前线程“睡眠”指定时间的millitime毫秒)。在指定的millitime毫秒时间内，当前线程是阻塞状态的
isAlive()：返回boolean，判断线程是否还活着
getPriority():获取当前线程的优先级
setPriority(int 1~10):设置线程优先级,默认为5,数越大优先级越高,获取cpu概率就越高,执行次数就越多,同级则随机调用
- MAX_PRIORITY：10
- MIN _PRIORITY：1

JDK1.5之前创建新执行线程有两种方法

继承Thread类的方式
实现Runnable接口的方式
后面会讲1.5后的实现Callable接口
后面还会将线程池创建管理线程

创建多线程的方式一：继承Thread类

创建一个继承于Thread类的子类
重写Thread的run()方法
将此线程要执行的内容声明在run()中
主线程main方法下创建Thread类的子对象
主线程main方法下通过此对象调用start(),可以:
1. 启动当前线程
2. 当前线程调用当前线程的run()方法
此时第二个线程诞生开始可以独立执行run()里面的方法,只需要等待系统分配cpu时间片就可以运行执行run()里面的方法.主线程也会继续运行下去,两个线程同时运行

问题1:不能直接调用run()而使用start()原因
- 如果直接对象.run()方法,则就是当前main方法调用run()方法,没有分出多线程,不满足需求
问题2:不能再次调用已经启动过线程的线程对象的start()方法
- 通过底层代码得知线程对象第一次启动线程时需要判断线程状态是否为0,如果为0就是当前线程没有被启动过,因此.start()启动成功,并且状态会改成非0。如果线程启动过了再.start()启动线程就会抛出IllegalThreadStateException错误.
- 因此我们必须重新在主线程main方法下创建Thread类的子对象,然后在主线程main方法下通过此对象调用start()，重新创建线程，线程执行run()方法。

package javase10;

public class Thread1 {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();//主线程main方法下创建Thread类的子对象myThread1
        myThread1.start();//主线程main方法下通过此对象myThread1调用start()启动第二个线程,然后第二个线程诞生开始独立执行run()里面的方法

        //问题1:不能直接调用run()而使用start()原因
//        myThread.run();//如果直接对象.run()方法,则就是当前main方法调用run()方法,没有分出多线程,不满足需求,因此不要

        //问题2:不能再次调用已经启动过线程的线程对象的start()方法
//        myThread1.start();//运行时会抛出IllegalThreadStateException错误,因为该线程对象已经启动过线程了
        MyThread myThread2 = new MyThread();//需要重新在主线程main重新在主线程main方法下创建Thread类的子对象myThread2
        myThread2.start();//在主线程main方法下通过此对象调用start()，重新创建线程，线程执行run()方法。

        //主线程打印[0,100)的奇数
        for(int i = 0;i < 100;i++){
            if(i % 2 != 0){
                System.out.println(i+"奇数"+Thread.currentThread().getName());//Thread.currentThread().getName(),获取当前执行线程名称
            }
        }
    }
}

//创建一个自定义继承Thread类的子类
class MyThread extends Thread{
    //重写Thread类的run()
    public void run() {
        for(int i = 0;i < 100;i++){//诞生的第二个线程打印[0,100)的偶数
            if(i % 2 == 0){
                System.out.println(i+"偶数"+this.getName());//this.getName()获取当前执行线程名称,Thread类的方法
            }
        }
    }
}

Thread类常用的方法

package javase10;

public class Thread2 {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("Thread : 1");//创建一个线程对象,并给线程对象赋予实例名
//        h1.setName("线程一");//setName()也可以赋予名字,不过有了含参构造就不需要这个方法了.

        h1.start();//启动线程对象


        Thread.currentThread().setName("主线程");//给主线程命名

        for(int i = 0;i < 100; i++){//主线程打印偶数
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
            if(i == 20){
                try {
                    h1.join();//主线程进入阻塞状态,将cpu权限交给h1线程对象的线程执行,直到该h1线程对象的线程执行释放后才到它执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        System.out.println(h1.isAlive());//判断h1线程对象线程是否存活
    }
}

class HelloThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {//循环执行100次
            try {
                sleep(10);//每次循环线程休眠10毫秒
            } catch (InterruptedException e) {//捕获中断异常对象
                e.printStackTrace();
            }

            if (i % 2 == 0) {//打印[0,100)的偶数
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
//            if (i % 20 == 0) {//一旦遇到能被20整除的数
//                yield();//放弃当前线程掌握的cpu,并重新进入就绪状态与别的线程抢夺cpu资源,以获取cpu时间片,有了上面的join()这里方法自然也无效了
//            }
        }
    }

    //创建线程并指定线程实例名
    public HelloThread(String name) {
        super(name);
    }
}

线程的调度

说明:由CPU选择执行哪个线程,执行多久

调度策略
- 时间片:同优先级线程组成先进先出队列（先到先服务），使用时间片策略
- 抢占式：高优先级的线程抢占到CPU使用权的概率就越高

package javase10;

public class Thread3 {
    public static void main(String[] args) {
        //创建自定义线程独显
        PriorityThread t1 = new PriorityThread();
        PriorityThread t2 = new PriorityThread();

        //设置自定义线程名
        t1.setName("自定义线程1");
        t2.setName("自定义线程2");

        //设置自定义线程优先级,默认为5,优先级越小优先级越高,获取cpu概率就越高,执行次数就越多,同级则随机调用
        t1.setPriority(Thread.MAX_PRIORITY);//Thread.MAX_PRIORITY=10
        t2.setPriority(5);
        Thread.currentThread().setPriority(4);//修改主线程main的线程优先级

        //启动线程,执行run()方法
        t1.start();
        t2.start();

        //main方法的代码
        for (int i = 0; i < 10; i++) {
            if(i%2!=0) System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

class PriorityThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if(i%2==0) System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

Thread类的拓展练习——买票

package javase10;
/**多个线程去执行抢票,票有100张*/
public class Thread4 {
    public static void main(String[] args) {
        BuyThick b1 = new BuyThick();
        BuyThick b2 = new BuyThick();
        BuyThick b3 = new BuyThick();

        b1.setName("窗口1");
        b2.setName("窗口2");
        b3.setName("窗口3");

        b1.start();
        b2.start();
        b3.start();
    }
}

class BuyThick extends Thread{
    //设置成私密就是为了只能使用run()来修改该值,设置成static是为了多线程在内存中共享只有一份的资源
    private static int ticket = 100;

    //减票操作
    @Override
    public void run() {
        while(ticket!=0){
            if(ticket==0)break;
            ticket--;
            System.out.println(Thread.currentThread().getName()+"买到了,还剩"+ticket+"票");
        }
    }
}

创建多线程的方式二：实现Runnable接口

创建一个实现了Runnable接口的实现类
实现类去实现Runnable中的抽象方法:run()
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

package javase10;

public class Thread5 {
    public static void main(String[] args) {
        //创建实体类对象
        RunThread r1 = new RunThread();
        //将对象作为参数传入到Thread类的构造器中，用于创建Thread类的对象
        Thread t1 = new Thread(r1);
        //设置线程名字
        t1.setName("线程1");
        //通过Thread类的对象调用start():①启动线程 ②调用当前线程的run() --> 调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程
        Thread t2 = new Thread(r1);
        t2.setName("线程2");
        t2.start();

    }
}

class RunThread implements Runnable{

    @Override
    public void run() {
        //遍历[0,10)的偶数
        for(int i = 0;i < 10;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

Runnable接口拓展练习——买票

package javase10;

public class Thread6 {
    public static void main(String[] args) {
        //实例化Runnable实现类
        RunByTicket r1 = new RunByTicket();
        //把Runnable实现类对象r1放入Thread构造器,此时的票数是一个实例变量,被b1,b2,b3线程对象共享,并且可以设置每个线程的名字
        Thread b1 = new Thread(r1,"窗口1");
        Thread b2 = new Thread(r1,"窗口2");
        Thread b3 = new Thread(r1,"窗口3");

        //这里就不用设置了
//        b1.setName("窗口1");
//        b2.setName("窗口2");
//        b3.setName("窗口3");

        b1.start();
        b2.start();
        b3.start();
    }
}

class RunByTicket implements Runnable{

    //不需要声明为static,因为...
    private int ticket = 100;

    //减票操作
    @Override
    public void run() {
        while(ticket!=0){
            if(ticket==0)break;
            ticket--;
            System.out.println(Thread.currentThread().getName()+"买到了,还剩"+ticket+"票");
        }
    }
}

继承方式和实现方式的联系与区别

开发中：优先选择：实现Runnable接口的方式
- 原因：
1. 实现的方式没有类的单继承性的局限性(写run的子类可能继承了别的父类,导致它不能继承Thread类重写run()方法)
2. 在继承方式下,买票的票数要声明成static静态变量,达到多线程共享一个资源的效果.而接口实现类的票数不需要声明成static静态变量,因为实现类实体化后，票数是一个实例变量，是唯一的，被接受该实现类对象而创建的Thread类共享。
3. 实现的方式更适合来处理多个线程有共享数据的情况(当时测试觉得实现方式在多线程下更明显，参考2.解释)
相同点：
- 因为Thread类也实现了Runnable接口，重写了run()。两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

(了解)线程分类

Java中的线程分为两类：一种是守护线程（gc()垃圾回收线程），一种是用户线程（主线程main）。它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
守护线程是用来服务用户线程的，通过在start()方法前调用Thread.setDaemon(true),可以把一个用户线程变成一个守护线程。Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程，当前JVM将退出。
守护线程,与主线程同生共死

线程生命周期

说明:JDK中用Thread.State类定义了线程的几种状态

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态，run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程的同步

需要线程同步的原因:

多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

线程同步的优缺点:

优点:操作同步代码时，只能有一个线程参与，其他线程等待。确保线程安全
缺点:但实际工作只有一个线程,效率低

触发同步机制的三种方法

1.同步代码块:

操作共享数据的代码，即为需要被同步的代码 --->不能包含代码多了，也不能包含代码少了
共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
同步监视器，俗称：锁。任何一个类的对象，对象数据类型都可以来充当锁。
在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
要求：多个线程必须要共用同一把锁

synchronized(同步监视器){
      //需要被同步的代码
}

2.同步方法:

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的
把synchronized像修饰符一样添加给方法

同步代码块与同步方法相比:

同步代码块相对比较好控制范围,但写起来比较复杂
同步方法就是在方法中加个修饰符,比较简单,但不好控制范围,范围大了性能就会有影响.

3.Lock锁（下面会讲）

买票实操举例(知识回顾)

之前的卖票演示,理想状态下卖票是希望不会出现重卖票和多卖票的区别

出现异常:但是当票数数量达到一定大时,出错概率就会增加,票数多卖重买的情况就会出现
原因分析:当某个线程通过判断条件操作车票的过程中，尚未操作完成时，cpu时间片就到了,到别得线程执行,别得线程也参与进来通过判断条件进行操作车牌，等之前那个线程再次获得时间片是他只需要操作减票,而不需要判断条件,因此到最后面总会多卖几张票,让票数数量变成负数

使用同步代码块处理实现Runnable的线程安全问题

说明:通过同步机制，来解决线程的安全问题。以卖票为例子,解决票数多卖重买的情况,因此改写Runnable线程实现多线程方式的卖票例子,解决线程安全问题.

package javase10;

public class Thread6 {
    public static void main(String[] args) {
        //实例化Runnable实现类
        RunByTicket r1 = new RunByTicket();
        //把Runnable实现类对象r1放入Thread构造器,此时的票数是一个实例变量,被b1,b2,b3线程对象共享,并且可以设置每个线程的名字
        Thread b1 = new Thread(r1,"窗口1");
        Thread b2 = new Thread(r1,"窗口2");
        Thread b3 = new Thread(r1,"窗口3");

        //这里就不用设置了
//        b1.setName("窗口1");
//        b2.setName("窗口2");
//        b3.setName("窗口3");

        b1.start();
        b2.start();
        b3.start();
    }
}

class RunByTicket implements Runnable{

    //不需要声明为static,因为...
    private int ticket = 10000;

    //减票操作
    @Override
    public void run() {
        /*线程1获取到cpu,线程1进来,首先判断票数是否不为空-->然后获取对象锁-->然后再执行一次判断仓库是否为空-->在没有执行减票操作时间cpu时间片就到了
        * 线程2获取到了cpu,线程2进来,首先判断票数是否为空-->然后获取对象锁,发现对象锁被线程1占用-->线程2进入阻塞状态,让出cpu
        * 线程3获取到了cpu,线程3与线程2同理
        * 又回到了线程1获取cpu,执行之前没完成的减票操作,操作完成后释放锁,此时线程1cpu时间片又到了
        * 线程2获取到了cpu,线程2获取对象锁成功,然后再执行一次判断仓库是否为空-->为空则不再执行减票操作
        * 线程3与线程2同理
        * 线程1获取到cpu，先判断票数是否为空，为空则直接结束，就被第一个校验拦截结束了，而不是被同步锁进行阻塞，因此效率更快*/
        while(ticket!=0) {
            //这里使用了同步代码块实现代码同步,顺便加上了双重校验,组合起来称为双重校验锁,效率相对较高。this是指当前的唯一的RunByTicket类型对象
            synchronized (this) {
                if (ticket == 0) break;
                ticket--;
                System.out.println(Thread.currentThread().getName() + "买到了,还剩" + ticket + "票");
            }
        }
    }
}

同步代码块处理继承Thread类的线程安全问题

说明:修改原有的Thread代码

package javase10;
/**多个线程去执行抢票,票有100张*/
public class Thread4 {
    public static void main(String[] args) {
        BuyThick b1 = new BuyThick();
        BuyThick b2 = new BuyThick();
        BuyThick b3 = new BuyThick();

        b1.setName("窗口1");
        b2.setName("窗口2");
        b3.setName("窗口3");

        b1.start();
        b2.start();
        b3.start();
    }
}

class BuyThick extends Thread{
    //设置成私密就是为了只能使用run()来修改该值,设置成static是为了多线程在内存中共享只有一份的资源
    private static int ticket = 100;

    //减票操作
    @Override
    public void run() {
        while(ticket!=0){
            //此时this表示的是b1、b2、b3三个对象，不符合多线程下需要使用同一个对象锁，我们这里使用三个对象都使用的对象数据类型
            synchronized (BuyThick.class) {
                if (ticket == 0) break;
                ticket--;
                System.out.println(Thread.currentThread().getName() + "买到了,还剩" + ticket + "票");
            }
        }
    }
}

同步方式原理图

线程安全的单例模式之懒汉式(完善之前的单例模式创建对象)

package javase10;

public class Thread7 {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getSingleton();
        Singleton s2 = Singleton.getSingleton();
        System.out.println(s1==s2);//true

    }
}

class Singleton{

    private Singleton(){}

    private static Singleton s1;

    public static Singleton getSingleton(){
        if(s1==null) {
            synchronized (Singleton.class) {
                if(s1==null) {
                    s1 = new Singleton();
                }
            }
        }
        return s1;
    }
}

死锁的问题

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁.
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，代码无法执行下去。因此我们使用同步时，要避免出现死锁。

演示死锁情况

package javase10;

public class Thread8 {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread() {
            @Override
            public void run() {
                synchronized (s1) {//当前线程使用s1对象作为同步代码块的同步监视器,然后为s1 s2 添加字符
                    s1.append("1");
                    s2.append("2");
                }
                try {
                    sleep(100);//线程休眠,增大两个线程交错的概率,线程休眠期间,依旧把握s1对象锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (s2){//此时线程休眠完毕,释放s1对象锁的同时也想获取s2对象锁
                    s1.append("3");
                    s2.append("4");
                }
            }
        }.start();//启动线程

        new Thread() {
            @Override
            public void run() {
                synchronized (s2) {//当前线程使用s2对象作为同步代码块的同步监视器,然后为s1 s2 添加字符
                    s1.append("5");
                    s2.append("6");
                }
                //这里不使用线程休眠
//                try {
//                    sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                synchronized (s1){//此时线程休眠完毕,释放s2对象锁的同时也想获取s1对象锁
                    s1.append("3");
                    s2.append("4");
                }
            }
        }.start();//启动线程

        /*出现死锁的原因(上面代码时有概率发生线程死锁情况):
        *   线程1在执行时持有的是s1对象锁,线程2页同步执行,持有的是s2对象锁.线程1执行完后手持s1对象锁进入短暂休眠状态,
        * 线程2执行完上层代码后想要释放s2对象锁同时获取s1对象锁执行下一步代码操作,但是线程1正在休眠,待线程1休眠完成后,
        * 线程1执行完上层代码后想要释放s1对象锁同时获取s2对象锁执行下一步代码操作,线程1线程2都不愿意撒手自己当前持有的对象锁,
        * 同时也想获取对象手上的线程锁,这样僵持的局面就导致了死锁*/
    }
}

Lock锁方式解决线程安全问题

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了Lock ，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
面试题：synchronized 与 Lock的异同？
- 相同：二者都可以解决线程安全问题
- 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
- Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
- 开发中大部分都是使用synchronize
实现线程同步优先推荐使用顺序：Lock锁>同步代码块>同步方法

实现接口Runnable方式演示Lock锁

package javase10;

import java.util.concurrent.locks.ReentrantLock;

public class Thread9 {
    public static void main(String[] args) {
        Windows w = new Windows();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t3.start();
        t2.start();
    }
}

class Windows implements Runnable {

    private int ticket = 100;
    /*实例化ReentrantLock,ReentrantLock类实现了Lock,它的含参构造是(boolean fair),true参数就是线程遵循先启动先执行的轮询策略
    *  效果:
    *   t1.start();
        t3.start();
        t2.start();
        ==>
        窗口1:售票，票号为: 100
        窗口3:售票，票号为: 99
        窗口2:售票，票号为: 98
        窗口1:售票，票号为: 97 
        ......
          */
    private ReentrantLock lock = new ReentrantLock(true);


    @Override
    public void run() {
        while (true) {
            try {

                lock.lock();//手动上锁,调用锁定方法：lock()这里的方法类似线程获取一个同步代码块里面的同步监视器,才能执行后面的方法,否则就进入阻塞状态

                if (ticket > 0) {

                    try {
                        Thread.sleep(10);//线程休眠可以增大导致票多卖重卖的情况
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":售票，票号为: " + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {

                lock.unlock();//手动解锁,调用解锁方法：unlock(),线程执行完后释放同步监视器给别的线程获取执行run()

            }
        }
    }
}

线程的通信

涉及Object类的三个方法

wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。sleep()不会释放同步监视器
notify():一旦执行此方法，就会通知被wait()且正在等待该对象监视器的单个线程即将被唤醒。但不会立即被唤醒。原因下面“线程通讯练习”案例有演示。如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll():一旦执行此方法，就会通知被wait()且正在等待该对象监视器的全部线程即将被唤醒。但不会立即被唤醒。
注意!!!!!!!!!!:
- wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中
- wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常
- wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中,并不是在Thread类中.

线程通讯练习

需求:使用两个线程打印1-3。线程1, 线程2 交替打印

提示:这里使用Lock锁也可以实现需求,线程轮流执行.只需要使用含参构造创建ReentrantLock对象就可以了(这里不做演示)

关于notify的使用提出的特别问题:这里不能设置while(num <= 3)而使用while(true)的原因是

package javase10;

public class Thread10 {
    public static void main(String[] args) {
        ThreadCommunication tc1 = new ThreadCommunication();
        Thread t1 = new Thread(tc1);
        t1.setName("线程1");
        Thread t2 = new Thread(tc1);
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

class ThreadCommunication implements Runnable {

    private int num = 1;
    public Object obj = new Object();

    @Override
    public void run() {
        /*      这里不能设置num <= 3而使用true的原因是:
         *    假如线程1第二次运行,num值为3,线程1获取对象锁,执行obj.notify,通知线程2即将被唤醒,但是此时对象锁被线程1占用,线程1能继续运行,而线程2也在同步代码块中不能动.
         * 等线程1执行到在控制台打印语句"线程1,即将要操作数3",然后执行num++将num变成4,线程1再执行obj.wait()进入阻塞状态并且释放对象锁,此时线程2可以运行往下运行,
         * 进入while循环,获取对象锁,执行obj.notify()通知释放线程1,但是此时对象锁被线程2占用,线程2继续往下执行,进入if判断条件,此时num=4不符合if条件,
         * 则线程2执行break语句.退出了同步代码块并释放了对象锁,同时结束了while循环,线程2结束.因为对象锁没哟被占用了,并且线程1已经被通知被唤醒,因此开始往下执行,
         * 进入while循环,获取对象锁,执行了obj.notify(),实际没有线程要被通知释放了,线程1执行if(num<=3),此时num=4不符合if条件,则线程1执行break语句,退出了同步
         * 代码块退出了同步代码块并释放了对象锁,同时结束了while循环,线程1结束.
         *    如果这里使用了num <= 3,则线程2无法进入while循环执行obj.notify,因此线程2永远无法被释放,以至于该线程永远处于阻塞状态*/
        while (true /*num<=3*/) {
            synchronized (obj) {

                obj.notify();//一旦执行此方法，就会通知被wait()且正在等待该对象监视器的单个线程即将被唤醒。但不会立即被唤醒,如果是线程1唤醒线程2,但此时同步监视器被线程1占用,因此线程1继续往下执行,线程2不能动

                if (num <= 3) {
                    try {
                        Thread.sleep(10);//增加异常概率,因此要加同步锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ",即将要操作数" + num);
                    num++;

                    try {
                        obj.wait();//使得调用如下wait()方法的线程进入阻塞状态,线程1执行完后进入阻塞状态并且释放同步监视器,如此循环便是两个线程轮流执行1~3的打印

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;//终止循环
                }
            }
        }
    }
}

(面试题)sleep()和wait()的异同

相同点
- 一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点
- 两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
- 调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
- 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

经典例题：生产者/消费者问题

需求:

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，
店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；
如果店中没有产品了，店员会告诉消费者等一下，
如果店中有产品了再通知消费者来取走产品。

package javase10;

public class Thread11 {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();
    }
}

class Clerk{

    private int productCount = 0;

    //生产产品
    public synchronized void produceProduct() {

        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ": 开始生产第" + productCount + "个产品");

            notify();
        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    //消费产品
    public synchronized void consumeProduct() {

        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;

            notify();
        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

class Producer extends Thread{//生产者
    private Clerk clerk;

    public Producer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ": 开始生产产品......");

        while(true){

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.produceProduct();
        }
    }
}

class Consumer extends Thread{  //消费者
    private Clerk clerk;

    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ": 开始消费产品......");

        while(true){

            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.consumeProduct();
        }

    }
}

JDK5.0新增线程创建方式

实现Callable接口创建线程

实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大之处
- call()可以有返回值的。
- call()可以抛出异常，被外面的操作捕获，获取异常的信息
- Callable是支持泛型的
- 需要借助FutureTask类，比如获取返回结果

package javase10;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Thread12 {
    public static void main(String[] args) {
        //创建Callable接口实现类的对象
        CallableThread c1 = new CallableThread();

        //将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(c1);

        /*FutureTask同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
        将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()*/
        new Thread(futureTask).start();

        /*通过FutureTask类型对象的get()方法获取Callable实现类中的call()方法返回值,需要捕获异常.
        这里FutureTask类型对象的get()返回值实际上就是FutureTask构造器参数上的Callable实现类重写call()的返回值*/
        try {
            Object sum = futureTask.get();
            System.out.println("1~100的偶数和为:"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class CallableThread implements Callable{

    //实现call方法，将此线程需要执行的操作声明在call()中,还可以抛出异常
    @Override
    public Object call() throws Exception {//可以抛出异常
        int sum = 0;
        for(int i = 1;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;//有返回值
    }
}

代码里面用的FutrueTask是Future接口唯一的实现类

可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
FutrueTask是Futrue接口的唯一的实现类
FutureTask同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

使用线程池创建线程

需要线程池的原因:
- 一些经常创建和销毁、使用量特别大的资源会特别影响性能.比如并发情况下的线程
思路:
- 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
好处:
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
  - corePoolSize：设置线程池核心线程数量(即使不用,也要保持一定数量的线程伴随线程池同生共死)
  - maximumPoolSize：设置线程池最大线程数量,要求值比核心线程数与poolSize大
  - keepAliveTime：线程没有任务时最多保持多长时间后会终止(非核心线程空闲时存活的时间)
  - ......
新提交一个任务时的处理流程
1、如果线程池的当前大小还没有达到基本大小(poolSize < corePoolSize)，那么就新增加一个线程处理新提交的任务；

2、如果当前大小已经达到了基本大小，就将新提交的任务提交到阻塞队列排队，等候处理.workQueue.offer(command)；

3、如果工作队列已满，并且当前大小poolSize没有达到maximumPoolSize，那么就新增线程来处理任务；

4、如果队列已满，并且当前线程数目也已经达到上限(maximumPoolSize)，那么意味着线程池的处理能力已经达到了极限，此时需要拒绝新增加的任务。至于如何拒绝处理新增

线程池相关API

JDK 5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
- <T>Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行Callable
- void shutdown()：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(int);创建线程池的同时设定该线程池核心线程的数量
  ,返回的是ExecutorService接口实现类的对象
- Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令

package javase10;

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

public class Thread13 {
    public static void main(String[] args) {

        //创建一个可重用固定线程数的线程池,设置poolSize=10,新增线程池大小
        ExecutorService threadPool = Executors.newFixedThreadPool(1);

        //验证出newFixedThreadPool()方法返回的是ExecutorService接口的实现类ThreadPoolExecutor
        System.out.println(threadPool.getClass());//验证出

        //父类对象threadPool强转成其实现类ThreadPoolExecutor,这样会多很多方法使用,比如执行时还可以传入Callable接口实现类的对象,还有线程池属性设置
        ThreadPoolExecutor service = (ThreadPoolExecutor) threadPool;

        //设置线程池的属性
        service.setCorePoolSize(2);//设置线程池核心线程数量
        service.setKeepAliveTime(10, TimeUnit.SECONDS);//设置非核心线程存活时间,参数分别为数字,单位
        service.setMaximumPoolSize(6);//设置线程池最大线程数量,要求值比核心线程数大


        //执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread1());//适用于执行实现Runnable接口的实现类实现类对象
        service.execute(new NumberThread2());//适用于执行实现Runnable接口的实现类实现类对象
//        service.submit(Callable callable);//适用于Callable实现类对象

        /*执行效果:
            pool-1-thread-1:0
            pool-1-thread-2:1
            pool-1-thread-1:2
            pool-1-thread-2:3
            ......
         */

        //关闭连接池
        service.shutdown();
    }
}

//业务
class NumberThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class NumberThread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

收录于