Java多线程

简介

普通方法调用和多线程区别

进程和线程

程序: 程序是指令和数据的集合。是一个静态的概念。

进程: 指程序的一次执行过程,是一个动态的概念。【进程是系统资源分配的单位】

一个进程可以有多个线程,如: 视频中同时听声音,看图像,看弹幕等。

一个进程至少包含一个线程,不然没有存在的意义。

【线程是CPU调度和执行的单位】

注意:
 1.此处的多线程是模拟出来的多线程。
   模拟多线程即在一个CPU的情况下,在同一个时间点,cpu只能执行一个线程,
   因为线程切换的很快,所有就有同时执行多个线程的错觉。
 2.真正的多线程是指有多个CPU,即多核,可以同时处理多个线程任务。

核心概念

• 线程就是一个独立的执行路径。
• 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如:主线程,gc线程等。
• main()称之为主线程,是程序运行的入口,用于执行整个程序。
• 在一个进程中,如果开辟了多个线程,线程的运行由CPU调度器来安排调度,故线程的执行的先后顺序是不受人为的干预的。
• 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制。
• 多线程会带来额外的开销,如CPU调度时间,并发控制开销等。
• 每个线程在自己的工作内存中运行,内存控制不当会造成数据不一致。

线程创建

继承Thread类【重点】

创建步骤:

1. 线程类继承java.lang.Thread类
2. 线程类重写run方法
3. 在main方法中创建线程类对象,调用start()方法开启线程

package com.carson.thread;

//方法一:通过继承Thread类创建多线程
/*  步骤:
 *  1.继承java.lang.Thread类
 *  2.重写run方法
 *  3.创建线程类对象,调用start()方法开启线程
 */
public class TestThread01 extends Thread{
    //重写run方法,开辟一个新线程
    @Override
    public void run() {
        //新线程的执行方法体
        for (int i = 0; i < 50; i++) {
            System.out.println("carson的新线程!");
        }
    }

    //main线程,主线程
    public static void main(String[] args) {
        //创建一个线程类的对象
        TestThread01 testThread01 = new TestThread01();
        //调用start()方法开启线程,注意:不能直接调用run()方法,那样就不是多线程交替			执行了
        //调用start()方法开启线程即线程进入就绪状态
        testThread01.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我是主线程!");
        }
        
        /* 注意:
        *    线程开启不一定立即执行,而是由CPU调度执行。
        * */
    }
}

多线程下载图片示例

package com.carson.thread;

//需先引入commons.io的jar包,放入lib目录,并在lib目录右键Add as library
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//多线程下载图片
public class TestThread02 extends Thread {
    private String url;
    private String fileName;

    public TestThread02(String url,String fileName){
        this.url = url;
        this.fileName = fileName;
    }

    //重写run()方法
    @Override
    public void run() {
        //线程执行体
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,fileName);
        System.out.println("下载了文件:"+fileName);
    }

    //主线程
    public static void main(String[] args) {
        //创建线程类对象
        TestThread02 t1 = new TestThread02("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fdpic.tiankong.com%2Fgk%2Fjs%2FQJ7116715583.jpg","1.jpg");
        TestThread02 t2 = new TestThread02("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic1.nipic.com%2F2008-12-01%2F200812183945888_2.jpg","2.jpg");
        TestThread02 t3 = new TestThread02("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic13.nipic.com%2F20110324%2F6999402_050849259122_2.jpg","3.jpg");
        //调用start方法开启线程,多线程执行顺序是不确定的,并不是按如下顺序执行区下载图片
        //调用start()方法开启线程即线程进入就绪状态
        t1.start();
        t2.start();
        t3.start();
    }
}

//下载器
class WebDownloader{
    //下载方法
    public void downloader(String url,String fileName){
        try{
            FileUtils.copyURLToFile(new URL(url),new File(fileName));
        }catch(IOException e){
            e.printStackTrace();
            System.out.println("IO异常,downloader方法出现异常!");
        }
    }
}

实现Runnable接口【重点】

创建步骤:

1. 定义线程类实现Runnable接口

2. 线程类重写run方法,编写线程执行体

3. 在main方法中,

   先创建实现Runable接口的线程类对象,

   再实例化Thread类对象,传入上面的线程类对象

   调用Thread类对象的start()方法开启线程

//通过实现java.lang.Runnable接口创建线程类
public class TestThread03 implements Runnable {
    //重写run方法,开辟一个新线程
    @Override
    public void run() {
        //新线程的执行方法体
        for (int i = 0; i < 50; i++) {
            System.out.println("carson的新线程!");
        }
    }

    //main线程,主线程
    public static void main(String[] args) {
        //创建一个实现Runnable接口线程类的对象
        TestThread03 testThread03 = new TestThread03();
        //再创建Thread类对象,传入上面的实现接口的线程类对象,调用start()方法开启线程
        //调用start()方法开启线程即线程进入就绪状态
        
        /*Thread thread = new Thread(testThread03);
        thread.start();*/
        
        new Thread(testThread03).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("我是主线程!");
        }
        /* 注意:
         *    线程开启不一定立即执行,而是由CPU调度执行。
         * */
    }
}

多线程下载图片示例

//多线程下载图片
public class TestThread04 implements Runnable {
    private String url;
    private String fileName;

    public TestThread04(String url,String fileName){
        this.url = url;
        this.fileName = fileName;
    }

    //重写run()方法
    @Override
    public void run() {
        //线程执行体
        WebDownloader1 webDownloader = new WebDownloader1();
        webDownloader.downloader(url,fileName);
        System.out.println("下载了文件:"+fileName);
    }

    //主线程
    public static void main(String[] args) {
        //创建实现接口的线程类对象
        TestThread04 t1 = new TestThread04("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fdpic.tiankong.com%2Fgk%2Fjs%2FQJ7116715583.jpg","1.jpg");
        TestThread04 t2 = new TestThread04("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic1.nipic.com%2F2008-12-01%2F200812183945888_2.jpg","2.jpg");
        TestThread04 t3 = new TestThread04("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic13.nipic.com%2F20110324%2F6999402_050849259122_2.jpg","3.jpg");
        //再创建Thread类对象,传入上面的实现接口的线程类对象,调用start()方法开启线程【静态代理】
        //调用start()方法开启线程即线程进入就绪状态
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}


//下载器
class WebDownloader1{
    //下载方法
    public void downloader(String url,String fileName){
        try{
            FileUtils.copyURLToFile(new URL(url),new File(fileName));
        }catch(IOException e){
            e.printStackTrace();
            System.out.println("IO异常,downloader方法出现异常!");
        }
    }
}

总结:

1. 继承Thread类创建多线程【不建议使用】

   子类继承Thread类具备多线程能力

   启动线程: 子类对象.start()

   不建议使用。

   2. 实现Runnable接口创建多线程【建议使用】

   实现接口Runnable接口具备多线程能力

   启动线程: Thread类传入目标对象+Thread对象.start()

   推荐使用:方便同一个对象被多个线程使用。

实现Callable接口【了解即可】

创建步骤:

1. 线程类实现Callable接口,需要设置接口类型即泛型接口
2. 重写call方法，需要抛出异常
3. 创建线程类对象
4. 创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(线程数量)
5. 提交执行: Future<泛型类型> result = ser.submit(线程类对象);
6. 获取结果: 泛型类型 r1 = result.get()
7. 关闭服务: ser.shutdownNow();

//多线程下载图片【实现Callable接口】
public class TestThread05 implements Callable<Boolean> {//需要设置返回类型,泛型接口的形式
    private String url;
    private String fileName;

    public TestThread05(String url,String fileName){
        this.url = url;
        this.fileName = fileName;
    }

    //重写call()方法,返回类型为泛型类型
    @Override
    public Boolean call() throws Exception {
        //线程执行体
        WebDownloader2 webDownloader = new WebDownloader2();
        webDownloader.downloader(url,fileName);
        System.out.println("下载了文件:"+fileName);
        return true;
    }

    //主线程
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建线程类对象
        TestThread05 t1 = new TestThread05("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fdpic.tiankong.com%2Fgk%2Fjs%2FQJ7116715583.jpg","1.jpg");
        TestThread05 t2 = new TestThread05("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic1.nipic.com%2F2008-12-01%2F200812183945888_2.jpg","2.jpg");
        TestThread05 t3 = new TestThread05("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fpic13.nipic.com%2F20110324%2F6999402_050849259122_2.jpg","3.jpg");
        //创建执行服务,传递线程数量
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取结果(需要抛出异常)
        Boolean rs1 = r1.get();
        Boolean rs2 = r2.get();
        Boolean rs3 = r3.get();
        //关闭服务
        ser.shutdownNow();
    }
}

//下载器
class WebDownloader2{
    //下载方法
    public void downloader(String url,String fileName){
        try{
            FileUtils.copyURLToFile(new URL(url),new File(fileName));
        }catch(IOException e){
            e.printStackTrace();
            System.out.println("IO异常,downloader方法出现异常!");
        }
    }
}

静态代理模式

真实对象和代理对象都要实现同一个接口

代理角色要代理真实角色去做事情

---

静态代理好处:

1. 代理对象可以做很多真实对象做不了的事情
2. 真实对象专注做自己的事情

示例如下:

//静态代理模式
/*
*真实对象和代理对象都要实现同一个接口
* 代理角色要代理真实角色去做事情
*/
public class StaticProxy {
    public static void main(String[] args) {
        //静态代理模式
        //new WeddingCompany(new You()).happyMarry();
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.happyMarry();
    }
}

//需要真实角色和代理角色共同实现的接口
interface Marry{
    void happyMarry();
}

//真实角色,你去结婚
class You implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("真实角色去结婚!");
    }
}

//代理角色,帮助你结婚
class WeddingCompany implements Marry{

    //代理谁-->真实角色实现的接口
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    //婚庆公司帮助结婚,可以做一些真实角色做不了的工作
    @Override
    public void happyMarry() {
        before();
        this.target.happyMarry();//这就是真实角色去结婚
        after();
    }

    private void before() {
        System.out.println("婚庆公司结婚前的准备工作!");
    }

    private void after() {
        System.out.println("结婚完成!");
    }
}

线程状态

线程的五大状态:

• 创建状态
• 就绪状态
• 运行状态
• 阻塞状态
• 死亡状态

具体的状态转换及事件:

线程方法

停止线程

注意:

1. 建议不要主动停止线程,让线程自动停止2. 主动停止线程建议使用标志位–>设置一个标志位+while循环+公共的停止线程方法3. 主动停止线程建议不要使用stop()/destroy()等过时或者JDK不建议使用的方法

//注意:
//1.建议不要主动停止线程,让线程自动停止
//2.主动停止线程建议使用标志位-->设置一个标志位+while循环+公共的停止线程的方法
//3.主动停止线程建议不要使用stop()/destroy()等过时或者JDK不建议使用的方法

测试主动停止线程示例(继承Runnable接口创建线程)
public class TestThread06 implements Runnable {
    //1.设置一个标志位
    private boolean flag = true;

    //重写run方法,线程体
    @Override
    public void run() {
        //当flag为true时,执行线程体,反之,不执行
        while(flag){
            System.out.println("子线程执行中...");
        }
    }

    //2.设置一个公共的方法停止线程
    public void stop(){
        this.flag = false;
    }

    //主线程进行测试
    public static void main(String[] args) {
        //创建线程类对象
        TestThread06 testThread06 = new TestThread06();
        //启动线程
        //调用start()方法开启线程即线程进入就绪状态
        new Thread(testThread06).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程执行中...");
            if(i==900){
                //调用stop方法切换标志位,让线程停止
                testThread06.stop();
                System.out.println("子线程已经停止了!!!!!!!");
            }
        }
    }
}

线程休眠

Thread sleep(long millis)：可以指定当前线程阻塞的毫秒数,即线程进入阻塞状态。

Thread sleep(long millis)存在异常InterruptedException.

Thread sleep()时间到达后,线程会从阻塞状态进入就绪状态。

Thread sleep()常用于 模拟网络延时,倒计时等。

每一个对象都有一个锁,sleep不会释放锁。

利用Thread sleep()模拟网络延时示例:

//利用Thread sleep()模拟网络延时示例
//作用: 放大问题的发生性
public class TestThread07 implements Runnable {
    //所剩票数
    private int ticketNums = 10;
    //重写run方法
    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                break;
            }
            //模拟网络延时
            try{
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票!");
        }
    }

    //主线程,测试类
    public static void main(String[] args) {
        //实例化线程类
        TestThread07 ticket = new TestThread07();
        //启动同个对象的多个线程【可以指定线程名字】
        //调用start()方法开启线程即线程进入就绪状态
        new Thread(ticket,"Carson").start();
        new Thread(ticket,"黄牛").start();
        new Thread(ticket,"老师").start();
    }
}

利用Thread sleep()倒计时示例:

//利用Thread.sleep()实现倒计时和打印系统当前时间public class TestThread08  {    public static void main(String[] args) throws InterruptedException {        //模式十秒倒计时        //tenDown();        //打印系统当前时间        while(true){            try{                //循环获取当前时间                Date nowTime = new Date(System.currentTimeMillis());                //指定格式输出当前时间                System.out.println(new SimpleDateFormat("HH:MM:ss").format(nowTime));                //休息一秒                Thread.sleep(1000);            }catch (InterruptedException e){                e.printStackTrace();            }        }    }    //模拟十秒倒计时    public static void tenDown() throws InterruptedException {        int second = 10;        System.out.println("点火10秒倒计时...");        while(true){            System.out.println(second--);            //休息1000毫秒即1秒            Thread.sleep(1000);            if(second<=0){                System.out.println("点火,起飞!");                break;            }        }    }}

线程礼让

方法: Thread yield();

礼让线程,即让正在执行中的线程释放CPU,重新让CPU进行线程选择和调度。

注意:

1. 礼让线程: 让当前正在执行的线程暂停,但不阻塞。
2. 礼让线程是让正在运行的线程从运行状态转为就绪状态。
3. 正在执行中的线程礼让出来后,CPU会重新调度线程,故礼让不一定成功,看CPU心情

//测试礼让线程//礼让不一定成功,看CPU心情public class TestThread09 {    public static void main(String[] args) {        //创建线程类对象        ThreadDemo demo = new ThreadDemo();        //开启线程        //调用start()方法开启线程即线程进入就绪状态        new Thread(demo,"A").start();        new Thread(demo,"B").start();    }}class ThreadDemo implements Runnable{    //重写run方法    @Override    public void run() {        for (int i = 0; i < 5; i++) {            if(i==3){                Thread.yield();                System.out.println("当前的线程是: "+Thread.currentThread().getName());            }            System.out.println("执行的是: "+Thread.currentThread().getName());        }    }}

线程插队

Thread 类中的join()方法可以实现"线程的插队"。【VIP待遇】

子线程对象.join() ——> 代表等待此子线程执行完成后,再执行其它线程,在此期间, 其它线程进入阻塞状态。

//测试join方法
//线程插队
public class TestThread10 implements Runnable {
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程VIP来了"+i);
        }
    }

    //主线程
    public static void main(String[] args) throws InterruptedException {
        //创建线程类对象
        TestThread10 testThread10 = new TestThread10();
        //由于是继承Runnable接口创建线程,需要创建Thread类对象
        Thread child = new Thread(testThread10);

        for (int i = 0; i < 500; i++) {
            if(i==200){
                /*注意:
                * join方法必须在线程start方法调用之后调用才有意义。
                * 这个也很容易理解：如果一个线程都没有start进入Runnable就绪状					  态，那它也就无法执行了。
                */
                //线程转换为就绪状态
                child.start();
                //插队,主线程等待child线程运行完再继续运行
                child.join();
            }
            System.out.println("主线程-->"+i);
        }
    }
}

观测线程状态

关于Java线程的状态,都规定在了Thread.State这个枚举类型中.

Thread.State枚举类中包括的线程状态有:

• NEW：一个尚未启动的线程的状态。即刚实例化线程类对象时的状态。

• RUNNABLE：即就绪状态、可运行状态。

• BLOCKED：阻塞状态。

• WAITING：正在等待另一个线程执行特定动作的线程处于此状态。

  例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；因为join()而等待的线程正在等待另一个线程结束。

• TIMED_WAITING：一个在限定时间内等待的线程的状态。即限时等待状态。

  造成线程限时等待状态的原因有五种，即：Thread.sleep(long)、Object.wait(long)、join(long)、LockSupport.parkNanos(obj,long)和LockSupport.parkUntil(obj,long)。

• TERMINATED：完全运行完成的线程的状态。即终止状态。线程不能再次启动。

观察线程状态示例:

//观察测试线程的状态
public class TestThread11 {
    public static void main(String[] args) throws InterruptedException {
        //匿名内部类写法(创建一个线程类,本质是通过继承Runnable接口实现)
        /*Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });*/
        
        //Lambda表达式写法(创建一个线程类,本质是通过继承Runnable接口实现)
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                //中间休息一下,好观察线程的状态
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("");
        });

        //观察线程启动/就绪前的状态
        //(Thread.State是一个枚举类型,封装了各个线程的可能状态)
        Thread.State state = thread.getState();
        System.out.println(state); //输出状态:NEW

        //观察线程启动后的状态
        thread.start();//启动线程,进入就绪状态
        state = thread.getState();
        System.out.println(state); //输出状态:RUNNABLE

        //持续输出线程的状态
        while(state != Thread.State.TERMINATED){
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
    }
}

线程的优先级

• 线程的优先级的作用。

  • 高优先级获得调度的概率高,一般是最先执行,但不是一定最先执行。
  • 低优先级获得调度的概率低,一般是晚执行,且概率低不代表一定不会被调度。

• 线程的优先级用数字来表示,范围从1-10

  • Thread.MIN_PRIORITY = 1;【线程最小的优先级号】
  • Thread.MAX_PRIORITY = 10;【线程最大的优先级号】
  • Thread.NORM_PRIORITY=5;【线程默认的优先级号】

• 使用以下方式可以改变或获取优先级:

  • 线程对象.getPriority()【获取线程优先级信息】
  • 线程对象.setPriority(int xxx)【设置线程的优先级号】
  • 优先级的设定建议设置在start()方法前。

注意:

​ 线程的优先级设置可以理解为线程抢占CPU时间片的概率大小，虽然概率比较大，但 是它不一定就是按照优先级的顺序去抢占CPU时间片的，具体的执行顺序还是要根据 谁先抢到了CPU的时间片，谁就先来执行。

​ 因此千万不要把设置线程的优先顺序当做是线程实际启动的优先顺序!

​ 因此，在实际应用中，优先级使用的意义也不大。

测试线程的优先级示例:

//测试线程的优先级
public class TestThread12 {
    //主线程最先执行,没有设置优先级，默认优先级为5
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
        //创建线程类对象
        MyPriority myPriority = new MyPriority();
        //创建Thread类对象
        Thread t1 = new Thread(myPriority,"t1线程");
        Thread t2 = new Thread(myPriority,"t2线程");
        Thread t3 = new Thread(myPriority,"t3线程");
        Thread t4 = new Thread(myPriority,"t4线程");
        Thread t5 = new Thread(myPriority,"t5线程");
        //先设置优先级,再启动线程
        t1.setPriority(1);
        t1.start();

        t2.setPriority(4);
        t2.start();

        t3.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        t3.start();

        t4.setPriority(7);
        t4.start();

        //优先级不在1-10范围之间,会报错IllegalArgumentException
        /*t5.setPriority(11);
        t5.start();*/
    }
}

//自定义线程类（通过实现Runnable接口）
class MyPriority implements Runnable{
    //重写Run()方法
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

守护(daemon)线程

Java中有两类线程: 用户线程(User Thread) , 守护线程(Daemon Thread)

---

只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；

只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。

Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。

---

User Thread 和Daemon Thread两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon Thread也就没有工作可做了，所以就没有继续运行的必要了。

守护线程常用方法

1. Thread daemonTread = new Thread();
   
   // 设定 daemonThread 为 守护线程，true代表守护线程,默认是false
   daemonThread.setDaemon(true);
   

2. Thread daemonTread = new Thread();
   
   // 验证当前线程是否为守护线程，返回 true 则代表是守护线程
   daemonThread.isDaemon();
   

守护线程代码示例:

//测试守护daemon线程【上帝保佑着人们】
public class TestThread13 {
    //主线程
    public static void main(String[] args) {
        //创建线程类对象
        God god = new God();
        Person person = new Person();
        //创建Thread类对象
        Thread threadGod = new Thread(god);
        Thread threadPerson = new Thread(person);
        //设置上帝类为守护线程
        threadGod.setDaemon(true);//默认参数是false,true代表设置为守护线程
        //启动守护线程
        threadGod.start();
        //启动用户线程
        threadPerson.start();
    }
}


//上帝(守护线程类)
class God implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("上帝保佑你....");
        }
    }
}

//被保佑的人(用户线程类/被守护线程类)
class Person implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("人们一生都开心的活着!");
        }
        System.out.println("=======Goodbye World!==========");
    }
}

输出:
	....
	人们一生都开心的活着!
	=======Goodbye World!==========
	上帝保佑你....
	上帝保佑你....
	上帝保佑你....
	上帝保佑你....
	
原先God线程类设置了while true,正常线程是会一直跑下去的,但对God线程类设置成了守护线程,所以God守护线程会等待Person线程类这个非守护线程执行完后,守护线程会自动随着jvm的停止而结束,而JVM的停止需要时间,故上面God类最后还会继续输出部分信息。

线程同步

简介

引例:

• 现实生活中我们都会遇到"同一个资源,多人使用"的问题,比如,食堂排队,每个人都想吃饭,最天然的解决办法是: 排队,一个一个来。
• 处理多线程问题时,多个线程访问同一个对象,并且某些线程还要修改这个对象,这个时候就需要线程同步了.
• 线程同步实质就是一种等待排队机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。

同步: 通俗理解即 一个一个来,不要出问题即可。

线程同步解决的问题: 多线程并发安全问题。

多线程并发: 同一个对象被多个线程同时操作。

线程同步仅仅需要队列就可以了吗?

答: 还是由现实生活的排队例子,万一有人不想排队,就会导致打起来,导致安全问题。故还需要一个锁机制。***每个被访问的对象都拥有一把锁(排它锁)***。正如现实生活中的排队上厕所,没有"门锁的话",一群人都涌进去了,导致安全问题

故线程同步的实现条件需要: 对列 +锁。

通俗理解，就是将所有线程排成一个队列，给要共享的资源上把锁，只有线程获得该资源的锁之后，才能访问该资源。

这也是线程同步的基本思想。所谓线程同步，是指同一进程中的多个线程相互协调工作从而达到一致性。使用线程同步，在解决线程安全问题的同时还能提高程序的性能。

锁机制(synchronized)

为了保证数据在方法中被访问时的正确性,在访问时加入锁机制(synchronized).

当一个线程获得对象的排它锁,这个线程会独占资源,而其它的线程必须等待,直到拥有锁的线程对象释放锁为止。

---

锁机制的缺点:

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

线程不安全案例

强调:

1. 本文所指的多线程并不是线程并行（真正的线程并行需要多个cpu)，而是通过cpu时间片轮换来完成的,这里的多线程是模拟的多线程。

2. Thread.sleep()方法的作用:

   首先要知道，程序运行的速度是非常快的，当CPU调度某个线程开始执行时，由于运行速度太快，此线程可能执行完之后CPU才开始调度其他线程，这样变成了一段时间内只有单个线程在运行,显然不符合并发的一段时间内多个线程运行的特点，因此我们希望能阻塞某个线程的运行，使得其他线程也有执行的“机会”，这就是sleep()方法的作用。

   在某个线程的run()方法里调用Thread.sleep(1000)后，会使当前正在运行的线程立即进入阻塞状态，1000ms后，阻塞状态解除，进入可运行态，等待CPU的再次调度。在这段时间里，其它线程有可能获取CPU的使用权，从而达到并发的效果。

   故调用sleep()方法可以扩大多线程执行时问题的发生性，从而帮助我们能够迅速发现程序存在的bug。

线程不安全的银行取钱示例

假设你和你妻子有100万存款，现在你俩同时去取钱，你想取50万，你妻子想取100万.

//线程不安全的银行取钱
public class UnsafeThread02 {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"个人基金");
        //取钱
        Drawing carson = new Drawing(account, 50, "你");
        Drawing other = new Drawing(account, 100, "妻子");
        //启动线程
        carson.start();
        other.start();
    }
}

//账户
class Account{
    int money;//账户金额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行:模拟取款
class Drawing extends Thread{
    Account account;//账户
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run(){
        //判断有没有钱
        if(account.money-drawingMoney<0){
            System.out.println(account.name+"钱不够了,取不了!");
            return;
        }
        //模拟延时,加大并发问题发生的可能性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额 = 余额-取的钱
        account.money = account.money-drawingMoney;
        //手里的钱
        nowMoney = nowMoney+drawingMoney;
        System.out.println(account.name+"余额为: "+account.money);
        System.out.println(Thread.currentThread().getName()+"手里的钱: "+nowMoney);
    }
}

程序运行结果如下:

发现余额竟然出现了负数！ 为什么会出现负数呢？

首先要知道, 每个线程都有自己的执行空间(即工作内存)，如果线程执行要用到某变量，

1. 首先要将变量从主内存拷贝的自己的工作内存空间。
2. 然后对变量进行操作：读取，修改，赋值等，这些均在线程的工作内存完成。
3. 操作完成后再将变量写回主内存。

在多线程环境下，由于线程会共享进程中的资源，故上述三步中任何一步都有可能被其他线程打断，在本例中,也就是两个线程共享account.money这个变量资源,也就是说，有可能account.money这个资源值还没来得及写入内存，就被其他线程读取或写入了。

分析-50出现的原因,脑部程序的执行过程:

	即假设“妻子的线程”先被CPU调度执行，在妻子的run()方法中，首先执行if判断，条件为假，继续执行下一句时,“妻子 的线程”强行被“你的线程”打断，“你的线程”读取到的account.money值仍然是原来的 100（万），这使得“你的线程”通过执行
account.money = account.money - drawingMoney,即100-50,使得account.money的值变为了50并成功写入了内存里。你的线程”执行完之后，CPU继续调度“妻子的线程”。妻子读取到的account.money值为被“你的线程”修改后的 50（万），由于此前已执行过if判断，故“妻子的线程”接着执行account.money = account.money - drawingMoney,即50-100=-50,使得account.money变成了-50.

线程不安全的买票示例

假设现在某铁路局某线仅有10张票了，有三种人都想要买票。

//线程不安全的买票示例
//线程不安全:多个线程拿到重复的票或者拿到不存在的票
public class UnsafeThread03 {
    public static void main(String[] args) {
        //创建线程类对象
        ButTickets station = new ButTickets();
        //创建Thread类并启动线程
        new Thread(station,"苦逼的我").start();
        new Thread(station,"牛逼的他人").start();
        new Thread(station,"可恶的黄牛").start();
    }
}


class ButTickets implements Runnable{
    //票
    private int ticketNums = 10;
    //外部停止线程的方式
    private boolean flag = true;

    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //买票方法
    public void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNums<=0){
            flag = false;//外部停止线程的方式
            return;//退出
        }
        //模拟延时,放大并发问题的发生性
        Thread.sleep(10);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票!");
    }
}

运行结果:

发现出现了多个线程拿到同一张票和拿到不存在的票(如拿到-1)的情况发生。解析如下:

线程不安全的买票问题解析:

   在本例中,笔者犯了一个错误,错误的以为多个线程是真正的并行工作的,错误的以为多个线程是	 同时去读取内存中的数据的,忽略了实际单CPU环境中线程的并发执行是通过时间片轮转实现      的,故CPU只能轮转的执行单个线程,故多个线程读取数据不是同时读取的,而是有先后顺序的,    故这里的多线程环境中每个线程读取到的数据不一定一样。
   
1. 在本例中,为什么多个线程拿到同一张票:
   脑补一下程序中线程的可能执行过程：
   在A线程里,执行完if语句判断和输出拿到的票数但还未将票数减去时,便被B线程打断,而B线程    也是执行完if语句判断和输出拿到的票数但还未将票数减去时,便被C线程打断,C线程执行if语    句判断和输出拿到的票数,此时这种情况三个线程会输出拿到相同的票数。
   
2. 在本例中,为什么线程拿到不存在的-1票:
   还剩下最后一张票的时候，脑补一下程序中线程的可能执行过程：
   在A线程里，刚执行完if语句判断，便被B线程打断，B线程刚执行完if语句判断，又被C线程打    断，C线程未被打断，成功执行完run()方法输出最后一张票同时将count(票数)更新成0，	 	C线程结束。之后假设CPU调度A线程，由于之前在A线程里已执行过if语句判断，那么再次调度	会接着if语句后面的代码执行，从而输出了第0张票同时使得count(票数)更新成了-1，A线程	  结束。最后CPU调度B线程，同理，由于之前在B线程里已执行过if语句判断，那么再次调度会	 接着if语句后面的代码执行，从而输出了第-1张票。

线程不安全的集合示例

//ArrayList本身是线程不安全的
//线程不安全的ArrayList示例
public class UnsafeThread01 {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            //Lambda表达式写法
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        //sleep()放大并发问题的发生性
        Thread.sleep(2000);
        System.out.println(list.size());//输出结果<10000,故是线程不安全的
    }
}

运行结果:

发现运行结果数组的大小是小于10000的,解析如下:

问题解析:

	虽然开启了10000个线程往ArrayList里加数据，但有可能出现：多个线程往ArrayList添加数据的时候，添加在了ArrayList的同一位置（ 比如ArrayList[1] ），这样ArrayList的大小自然就不足10000了。

线程不安全总结:

如上面三个例子所示,线程不安全问题出现的核心原因,就是***多个线程间不确定地切换***。

故线程同步的关键就是: 线程间形成队列+锁机制。

同步方法及同步块[解决线程不安全]

即synchronized关键字的使用。

它包括两种用法: synchronized方法 和 synchronized块。

1. synchronized方法【同步方法】

//同步方法: 在方法修饰符添加一个synchronized关键字即可
//注意:同步方法默认锁的是方法所在的线程类对象,即this
public synchronized void method(int args){};

synchronized同步方法优点:

1. synchronized方法控制对"对象"的访问,而每个资源对象对应一把锁。
2. 当两个线程同时对一个对象的某个方法进行调用时，只有一个线程能够抢到该对象的锁，因为一个对象只有一把锁。抢到该对象的锁之后，其他线程就无法访问该对象的所有synchronized方法，但仍可以访问该对象中的非synchronized方法。

synchronized同步方法缺陷:

1. 若将一个大的方法申明为synchronized将会影响效率。
2. 因为只有方法里面有产生修改的那部分内容才需要同步,同步太多,影响效率。

改进线程不安全的买票为线程安全的,改动如下:

//加一个关键词synchronized实现同步方法,锁的是这个方法的所在的对象:即this
public synchronized void buy() throws InterruptedException {
    //判断是否有票
    if(ticketNums<=0){
        flag = false;//外部停止线程的方式
        return;//退出
    }
    //模拟延时,放大问题的发生性
    Thread.sleep(100);
    //买票
    System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票!");
}

2. 同步块

//格式如下
//锁的对象就是共享的量,变化的量,即增删改的量所在的类对象
//把共享资源变成同步块,运行同步块中的代码需要获得锁,同步块结束了就释放锁。
synchronized (Obj) {};


//注意:
	/*
	Obj称为同步监视器,Obj可以是任何对象,但推荐将"共享资源所在类对象"作为同步监视器。
	故可将同步监视器通俗理解为: 需要被多个线程共享和修改的资源对象。
	而上面的同步方法中无需指定同步监视器,因为同步方法的同步监视器默认就是this,即
	同步方法所在的类的对象本身.上面例子中由于共享资源是ticketNums,而其所在类就是run方法所在的线程类本身,即this,故可以直接将run()方法加上synchronized变为同步方法。
	*/

	/*
	同步监视器的执行过程:
		1.第一个线程访问,锁定同步监视器,再执行其中代码,
		2.第二个线程访问,发现同步监视器被锁定,无法访问
		3.第一个线程访问完毕,解除同步监视器
		4.第二个线程访问,发现同步监视器没有锁,然后锁定并访问。
	*/

改进线程不安全的银行取钱为线程安全的,改动如下:

//银行:模拟取款
class Drawing extends Thread{
    Account account;//账户
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run(){
        //放入同步块,变为线程安全的
        //因为是account.money在变动,同步监视器为:account
        synchronized (account){
            //判断有没有钱
            if(account.money-drawingMoney<0){
                System.out.println(account.name+"钱不够了,取不了!");
                return;
            }
            //模拟延时
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额 = 余额-取的钱
            account.money = account.money-drawingMoney;
            //手里的钱
            nowMoney = nowMoney+drawingMoney;
            System.out.println(account.name+"余额为: "+account.money);
            System.out.println(Thread.currentThread().getName()+"手里的钱: "+nowMoney);
        }
    }
}

改进线程不安全的ArrayList集合为线程安全的,改动如下:

public static void main(String[] args) throws InterruptedException {
    List<String> list = new ArrayList<String>();
    for (int i = 0; i < 10000; i++) {
        //Lambda表达式写法
        new Thread(()->{
            //增加成同步块,即获得同步块资源的锁
            synchronized (list){
                list.add(Thread.currentThread().getName());
            }
        }).start();
    }
    //sleep()放大并发发生的可能性
    Thread.sleep(2000);
    System.out.println(list.size());//输出结果<10000,故是线程不安全的

}

JUC下默认线程安全集合示例:

//测试JUC(Java Util Concurrent)中线程安全的集合
public class SafeThread {
    public static void main(String[] args) throws InterruptedException {
        //CopyOnWriteArrayList是JUC包下线程安全的集合类型
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            //Lambda表达式写法
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        //sleep(),加大并发发生的可能性
        Thread.sleep(2000);
        //输出集合的大小
        System.out.println(list.size());
    }
}

死锁

什么是死锁?

多个线程各自占有一些共享资源,并且互相等待其它线程占有的资源才能运行,从而导致的两个或者多个线程都在等待对方释放资源,都停止执行的情形。 
即: 多个线程互相抱着对方需要的资源,然后形成僵持的局面。

什么情况下会发生死锁?

某一个同步块同时拥有"两个以上对象的锁"时,就可能会发生"死锁"的问题。

产生死锁的四个必要条件:
	1. 互斥条件:一个资源每次只能被一个进程使用。
	2. 请求与保持条件:一个进程因请求资源而堵塞时,对已获得的资源保持不放。
	3. 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺。
	4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
 只要破坏上述条件中的一个或多个条件,就可以避免死锁的发生。

代码示例:

假设有"灰姑凉"和“白雪公主”两个人要化妆,只有一份口红和一份镜子情况下,可能形成死锁。

//演示死锁:多个线程互相抱着对方需要的资源,然后形成僵持的局面
public class DeadLock {
    public static void main(String[] args) {
        MakeUp g1 = new MakeUp(0,"灰姑凉");
        MakeUp g2 = new MakeUp(1,"白雪公主");
        g1.start();
        g2.start();
    }
}

//口红
class LipStick{}

//镜子
class Mirror{}

//线程类
class MakeUp extends Thread{
    //共享的资源只有一份,用static保证只有一份
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的女孩姓名

    public MakeUp(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆,互相持有对方资源的锁
    private void makeup() throws InterruptedException {
        if(choice==0){
            //同步块,先获得口红
            synchronized (lipStick){
                //this指向本类实例对象
                System.out.println(this.girlName+"获得口红的锁!");
                //sleep(),放大并发发生的可能性
                Thread.sleep(1000);
                //同步块,一秒钟后想获得镜子
                synchronized (mirror){
                    System.out.println(this.girlName+"获得镜子的锁!");
                }
            }
            /*//同步块,一秒钟后想获得镜子
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子的锁!");
            }*/
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁!");
                //sleep(),放大并发发生的可能性
                Thread.sleep(1000);
                synchronized (lipStick){//一秒钟后想获得口红
                    System.out.println(this.girlName+"获得口红的锁!");
                }

            }
            /*synchronized (lipStick){//一秒钟后想获得口红
                System.out.println(this.girlName+"获得口红的锁!");
            }*/
        }
    }
}

运行结果:

结果：（发生死锁,程序卡住）

原因分析:
	程序中发生了"锁中锁"现象。
	我们知道,synchronized(){}同步块中,要执行同步块中的代码需要获得共享资源的锁,
	而当同步块中的代码执行完后才会释放共享资源锁。
	而上面两个并发线程产生了"锁中锁"现象,
	1."灰姑凉"线程可以先获得口红资源锁,其外层的同步块可以执行
	但线程休息一秒后，"灰姑凉"线程想要获得镜子资源锁,但镜子资源锁已被"白雪公主"占据,
	导致"灰姑凉"线程的内层同步块不可以执行,最终导致外层不能运行结束, 从而释放不了口红      资源锁.
	2.同理,"白雪公主"线程也可以先获得镜子资源锁,其外层的同步块也可以执行,但线程休息一	秒后,"白雪公主线程"想获得口红资源锁,但口红资源已被"灰姑凉"占据,导致"白雪公主"线程     的内层同步块不可以执行,最终导致外层同步块不能运行结束,从而释放不了镜子资源锁.
	3."锁中锁"的最终结果就是:
	 已获得口红资源的"灰姑凉"线程由于不能获得镜子资源而阻塞,
	 已获得镜子资源的"白雪公主"线程由于不能获得口红资源而阻塞,
	 导致两个线程进入僵持局面。

改进代码,避免"锁中锁"导致"死锁":

public class DeadLock {
    public static void main(String[] args) {
        MakeUp g1 = new MakeUp(0,"灰姑凉");
        MakeUp g2 = new MakeUp(1,"白雪公主");
        g1.start();
        g2.start();
    }
}

//口红
class LipStick{}

//镜子
class Mirror{}

//线程类
class MakeUp extends Thread{
    //共享的资源只有一份,用static保证只有一份
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//使用化妆品的女孩姓名

    public MakeUp(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆,互相持有对方资源的锁
    private void makeup() throws InterruptedException {
        if(choice==0){
            //同步块,先获得口红
            synchronized (lipStick){
                //this指向本类实例对象
                System.out.println(this.girlName+"获得口红的锁!");
                //sleep(),放大并发发生的可能性
                Thread.sleep(1000);
                /*//同步块,一秒钟后想获得镜子
                synchronized (mirror){
                    System.out.println(this.girlName+"获得镜子的锁!");
                }*/
            }
            //同步块,一秒钟后想获得镜子
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子的锁!");
            }
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.girlName+"获得镜子的锁!");
                //sleep(),放大并发发生的可能性
                Thread.sleep(1000);
                /*synchronized (lipStick){//一秒钟后想获得口红
                    System.out.println(this.girlName+"获得口红的锁!");
                }*/

            }
            synchronized (lipStick){//一秒钟后想获得口红
                System.out.println(this.girlName+"获得口红的锁!");
            }
        }
    }
}

运行结果:

运行结果发现:两个线程不会形成死锁,程序正常结束。

原因分析:
	程序去除了"锁中锁",改成以先后顺序获得锁。
	我们知道,synchronized(){}同步块中,要执行同步块中的代码需要获得共享资源的锁,
	而当同步块中的代码执行完后才会释放共享资源锁。
	在两个并发执行的"灰姑凉"线程和"白雪公主"线程中:
	1."灰姑凉"线程可以先获得口红资源锁,故第一个同步代码块得以执行和结束,最终释放口红资源。由于"白雪公主"释放了镜子资源,故第二个同步代码块得以运行和结束。
	2."白雪公主"线程可以先获得镜子资源锁,故第一个同步代码块得以执行和结束,最终释放镜子资源。由于"灰姑凉"释放了口红资源,故第二个同步代码块得以运行和结束。
	3.故程序运行的最终结果是:"灰姑凉"线程和"白雪公主"线程资源需求都得以满足.

Lock锁[解决线程不安全]

• 从JDK5.0开始,Java提供了更强大的线程同步机制—即通过显式定义同步锁对象来实现线程同步。同步锁使用Lock对象充当。

• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。

  锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。

• ReentrantLock类【可重入锁】实现了Lock接口,它拥有与synchronized相同的并发性,在实现线程安全的控制中,比较常用的是ReentrantLock,其可以***显式的加锁和释放锁,类似PV操作***。

定义格式如下:

class A{
    //定义实现Lock接口的可重入锁对象
    private final ReentrantLock lock = new ReentrantLock();
    //显式给临界区加锁和解锁,类似PV操作
    public void m(){
        lock.lock();//显式加锁
        //临界区
        try{
            //保证线程安全的执行代码
        }finally{
            //显式释放锁
            lock.unlock();
        }
    }
}

以线程不安全的买票加可重入锁代码示例:

//测试Lock锁【可重入锁】
public class TestLock {
    public static void main(String[] args) {
        //实例化线程类对象
        TestLock2 testLock2 = new TestLock2();
        //实例化Thread类对象并启动线程
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}


//线程类
class TestLock2 implements Runnable{
    //票数
    int ticketNums = 10;
    //定义实现Lock接口的可重入锁对象
    private final ReentrantLock lock = new ReentrantLock();

    //重写run方法
    @Override
    public void run() {
        while (true){
            try{
                lock.lock();//加锁
                if(ticketNums>0){
                    try{
                        //sleep(),增大并发发生的可能性
                        Thread.sleep(1000);
                        System.out.println(ticketNums--);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

线程同步方法对比

synchronized与Lock锁的对比:

1. Lock是显式锁(需要手动加锁和释放锁),synchronized是隐式锁,synchronized其中的代码执行完后自动释放锁。
2. Lock只有代码块锁，而synchronized有代码块锁和方法锁。
3. 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好,且可扩展更多的子类。

线程同步方法优先使用顺序

Lock锁 > 同步代码块 >同步方法

关于线程同步的相关内容,也可参考:–>详解多线程同步

线程协作(线程通信)

线程通信方法

Java提供了几个解决线程之间通信的方法。

注意：上面均是Object类的方法,但都***只能在同步方法或者同步代码块中使用***,否则会抛出异常illegalMonitorStateException.

强调关于wait()，有以下几个要点需要注意：

• wait()方法是Object类中的方法，其作用是使当前线程进入wait状态（将当前线程放入该对象的“预执行队列”中，等待状态可以理解为阻塞状态），并且在wait()方法所在代码行处停止执行，直到被 notify() 或 notifyAll() 通知或被中断为止。
• 在***调用wait()方法前，当前线程必须获得该对象的锁，也就是说，只能在同步方法或者同步代码块中调用wait()方法***。
• 在调用wait()方法后，当前线程会立即释放该对象的锁。
• 与无参的wait()方法不同的是，有参的wait()方法并不需要其他线程执行 notify() 或者 notifyAll() 来唤醒，只要超过了设定时间，线程会自动解除阻塞状态。

强调关于notify()和notifyAll()，也有几个要点需要注意：

• notify()方法是用来通知处于wait状态的线程-----你可以取得当前对象的锁了。
• 调用notify()方法之后，如果处于wait状态的线程不止一个，则CPU会随机调度一个线程向其发出通知------你可以取得当前对象的锁了。
• notifyAll()则是通知所有处于wait状态的线程------你们可以开始竞争当前对象的锁了。
• 与调用wait()方法不同，在调用notify()或notifyAll()方法后，当前线程不会立即释放该对象的锁，而是要等当前线程执行完synchronized代码块后，才会释放锁.

sleep()方法和wait()方法的区别:

• sleep()是Thread类中的一个静态方法，作用于当前线程。而wait()是Object类中的方法，任何实例对象均可以调用，作用于对象本身。
• sleep()不会释放锁，也不会占用锁。而wait()会释放锁，而且调用它的前提是当前线程持有锁。
• sleep()方法可以在任何合法的地方调用。而wait()只能在同步方法或同步代码块中调用。
• 对于含参的sleep()，不管设定时间内有没有其他线程占用锁，设定时间过后都会使当前线程进入可运行态。而含参的wait()在设定时间超过之后，如果有线程占用了锁，则原线程立即进入可运行态；如果没有线程占用锁，则原线程继续执行（运行态）。

生产者消费者问题

什么是生产者消费者问题

1.假设仓库中能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费。
2.如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止。
3.如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止。

问题分析

这是一个线程通信问题,生产者和消费者共享同一个资源,且生产者和消费者之间相互依赖互为条件

1.对于生成者:没有生产产品之前,要通知消费者等待,而生产了产品之后,又需要马上通知消费者去    消费。
2.对于消费者:在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费。

生产者消费者问题的解决办法

1. 管程法。
2. 信号灯法。

管程法

管程法的利用了缓冲区过渡。

管程法的组成: 生产者+消费者+缓冲区

生产者:负责生产数据的模块。

消费者:负责处理数据的模块。

缓冲区:消费者不能直接使用生产者的数据,它们之间有个"缓冲区"。

生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据。

代码示例：

/测试：生产者消费者模型-->利用缓冲区解决:管程法
//生产者+消费者+产品+缓冲区
public class TestThread14 {
    public static void main(String[] args) {
        //实例化缓冲区对象
        SynContainer synContainer = new SynContainer();
        //实例化生产者消费者线程并启动线程
        new Productor(synContainer).start();
        new Consumer(synContainer).start();
    }

}

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

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

//产品
class Chicken{
    int id;//产品编号
    public Chicken(int id){
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //需要一个容器大小【存储10只鸡】
    Chicken[] chickens = new Chicken[10];
    //容器存储的产品数量
    int count = 0;
    //生产者放入产品(涉及线程并发,设置为同步方法)
    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;
    }
}

信号灯法

即:通过设置标志位的真假,协调进程之间的关系。

代码示例:

//测试生产者消费者问题:信号灯法,设置标志位解决
public class TestThread15 {
    public static void main(String[] args) {
        //产品
        Tv tv = new Tv();
        //生产者和消费者线程
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者,演员
class Player extends Thread{
    Tv tv;
    public Player(Tv tv){
        this.tv = tv;
    }
    //重写run方法


    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.tv.play("快乐大本营;");
            }
            else{
                this.tv.play("抖音");
            }
        }
    }
}

//消费者,观众
class Watcher extends Thread{
    Tv tv;
    public Watcher(Tv tv){
        this.tv = tv;
    }
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.tv.watch();
        }
    }
}

//产品,演员录制的电视节目
class Tv{
    //电视节目
    String show;
    //设置信号灯,标志位
    //标志位为真,则演员录制节目,观众等待
    //标志位为假,则观众观看节目,演员等待
    boolean flag = true;

    //演员录制节目
    public synchronized void play(String show){
        //标志位为假,演员等待
        if(!flag){
            try{
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //标志位为真,演员录制节目
        System.out.println("录制了:"+show);
        this.show = show;

        //录制好后,通知观众.并转换标志位
        this.notifyAll();
        this.flag = !this.flag;
    }

    //观众观看节目
    public synchronized void watch(){
        //标志位为真,观众等待
        if(flag){
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        //标志位为假,观众观看节目
        System.out.println("观看了:"+show);

        //观看后,通知演员录制,并转换标志位
        this.notifyAll();
        this.flag=!this.flag;
    }
}

线程池

什么是线程池?

提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。
线程池即存放多个已创建好的线程的"池子"。

为什么需要线程池?

当没有使用线程池时,我们每当需要一个线程就需要去创建一个线程;而经常创建和销毁线程对性能的影响很大。

当使用线程池:可以避免频繁创建销毁线程,实现线程的重复利用,类似公共交通工具。

使用线程池的好处?

1.提高响应速度(减少了创建和销毁线程的时间)
2.降低资源消耗(重复利用线程池中线程,不需要每次都创建)
3.便于线程管理
	corePoolSize:核心池的大小
	maximumPoolSize:最大线程数
	keepAliveTime:线程没有任务时最多保持多长时间后终止

使用线程池

JDK5.0起提供了线程池相关API: 如ExecutorService接口和Executors工厂工具类。

---

ExecutorService: 是真正的线程池接口。常见子类: ThreadPoolExecutor.

• void execute(Runnable command):执行命令,没有返回值,一般执行Runnable实现类.
• Future submit(Callable task):执行任务,有返回值,一般执行Callable实现类。
• void shutdown(): 关闭线程池。

---

Executor: 工具类,线程池的工厂类,用于创建并返回不同类型的线程池。

示例代码;

//测试线程池
public class TestThread16 {
    public static void main(String[] args) {
        //1.创建服务,创建线程池
        //newFixedThreadPool参数为：线程池的大小（线程数量)
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2.执行(4个线程示例)
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //3.关闭线程池
        service.shutdown();
    }

}

//线程类
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

关于线程池的更多知识可参考:线程池详解

创作不易,欢迎点赞/评论！