Java多线程

JavaThread

01Thread简介

1.1、概述

• Thread简介

• Thread实现（重点）

• 线程状态

• 线程同步（重点）

• 线程通信问题

• 高级主题

1.2、线程简介

多任务：比如一个人同时做两件事；边吃饭边玩手机…看起来是多任务其实本质我们的大脑在同一时间依旧只做了一件事。宏观并行，微观串行

多线程：多条线路同时执行，多条执行路径，主线程和子线程并行交替执行

普通方法调用和多线程

程序.进程.线程

在操作系统中运行的程序就是进程，比如QQ、播放器、游戏、IDEA等等…一个进程可以有多个线程，如视频中有同时有声音、图像、弹幕、等

Process（进程）与Thread（线程）

• 程序是指令和数据的合理化的集合，其本身没有任何运行的含义，是一个静态的概念。
• 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位

**注意：**很多多线程是模拟出来的，真正的多线程是指有很多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以有同时执行的错觉。

核心概念：

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

02线程创建

1.1、继承Thread类（重点）

学习提示：查看JDK帮助文档

• 自定义线程类

• 重写run()方法，编写线程执行体

• 创建线程对象，调用start（）方法启动线程

• 线程不一定立刻执行，由CPU调度执行

package rabbit.demo01;

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
//总结：注意线程开启不一定立刻执行，由CPU调度执行
public class TestThread1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i <20 ; i++) {
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        testThread1.run();//调用start()方法开启线程
        //testThread1.start();

        for (int i = 0; i <20; i++) {
            System.out.println("我在学习多线程---"+i)
        }
    }
}

练习：网图下载代码懒得写不会！

1.2、实现Runnable接口（重点）

学习提示：查看JDK帮助文档

• MyRunnable类实现Runnable接口
• 实现run（）方法，编写线程执行体
• 创建线程对象，调用start（）方法启用线程
• 推荐使用Runnable对象，因为Java单继承的局限性

package rabbit.demo01;

//创建线程方式2： 实现Runnable接口，重写run方法，执行线程需要丢入Runnable接口实现类。调用start（）方法
public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i <20 ; i++) {
            System.out.println("我在学习，学习使我快乐！"+i);
        }
    }

    public static void main(String[] args) {//创建Runnable接口实现类对象
        //创建Runnable接口实现类对象
        TestThread3 testThread3 = new TestThread3();
//        Thread thread = new Thread(testThread3);//创建线程对象，通过线程对象来开启我们的线程，代理
//        thread.start();

        new Thread(testThread3).start();
        
        for (int i = 0; i <20 ; i++) {
            System.out.println("不要睡觉！不要睡觉！"+i);
        }
    }
}

小结：

继承Thread类

• 子类继承Thread类具备多线程能力
• 启动线程：子类对象.start（）
• 不建议使用：避免OOP单继承性

NewThread thread = new NewThread();
thread.start();

实现Runnable接口

• 实现接口Runnable具有多线程能力

• 启动多线程：传入目标对象+Thread对象.start（）

  Thread thread = new Thread(new NewRunnable());

• 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

//一份资源
StartThread st = new StartThread();

//多个代理
new Thread(st,"哦豁").start;
new Thread(st,"豁哦").start;
new Thread(st,"哦豁豁").start;

初识并发

买火车票哈哈哈😄

package rabbit.demo01;

//多个线程同时操作同一个对象
//买火车票
//发现问题：多线程操作同一个资源情况下，线程不安全，数据紊乱。（线程同步时再解决并发）
public class TestThread4 implements Runnable {
    //票数
    private int ticketNums = 10;


    @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) {
        TestThread4 ticket = new TestThread4();
        new Thread(ticket,"韩韩").start();
        new Thread(ticket,"小兔").start();
        new Thread(ticket,"黄牛").start();
    }
}

结果

小兔-->拿到了第10票！
黄牛-->拿到了第8票！
韩韩-->拿到了第9票！
黄牛-->拿到了第7票！
小兔-->拿到了第6票！
韩韩-->拿到了第5票！
小兔-->拿到了第4票！
韩韩-->拿到了第3票！
黄牛-->拿到了第2票！
黄牛-->拿到了第1票！
韩韩-->拿到了第-1票！
小兔-->拿到了第0票！

进程完成，退出码 0

小案例：🐢🐇赛跑-Race

1. 首先来个赛道距离，然后要离重点越来越近
2. 判断比赛是否结束
3. 打印出胜利者
4. 🐢🐇赛跑开始
5. 故事中是🐢的坚持不懈赢了，🐇以为自己很厉害就睡觉，所以我们来模拟🐇睡觉？
6. 终于!还是🐇赢了故事还是故事！

package rabbit.demo01;

//🐢🐇赛跑
public class Race implements Runnable {
    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {
//            if (Thread.currentThread().getName().equals("🐇")&& i%10==0){//让兔子睡觉？
//                try {
//                    Thread.sleep(0);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            //如果比赛结束了就停止程序
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"米");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps) {
        //判断是否有胜利者
        if (winner!=null){//已经存在胜利者了
            return true;
        }{
            if (steps==100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is"+winner);
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"🐇").start();
        new Thread(race,"🐢").start();
    }
}

1.3、实现Callable接口（了解即可，未来的核心重点）

1. 实现Callable接口，需要返回值
2. 重写call方法，需抛出异常
3. 创建目标对象
4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5. 提交执行：Future result1 = ser. submilt(1);
6. 获取结果;boolean r1 = result.get();
7. 关闭服务：ser.shutdownNow();

利用callable改造图片案例

callable的好处：

1. 可以定义返回值
2. 可以抛出异常

1.4、静态代理

• 你：真实角色
• 婚庆公司：代理你，帮你处理结婚的事
• 结婚：实现都实现结婚接口即可

演示：实现静态代理对比Thread

package rabbit.demo02;
/*
静态代理模式总结：
真实对象和代理对象都要实现同一个接口
代理对象代理对象代理真实角色
好处：
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情
 */
public class StacticProxy {
    public static void main(String[] args) {
        You you = new You();//你要结婚
    
        new Thread(()-> System.out.println("我爱你")).start();

        new WeddingCompany(new You()).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 after() {
        System.out.println("结婚之后，收尾款");
    }

    private void before() {
        System.out.println("结婚之前，布置现场");
    }
}

1.5、Lambda表达式

• λ 希腊字母表中排序第十一位的字母，英语名为Lambda

• 避免匿名内部类定义过多

• 其实质属于函数式编程的概念

new Thread (()->System.out.println("多线程学习...")).start();

• 为什么要使用Lambda表达式
  • 避免匿名内部类定义过多
  • 可以让你的代码更简洁
  • 去掉了一堆杂七杂八的代码，只留下核心的逻辑

用多了就看习惯了

package rabbit.demo03;/*推导lamda表达式 */public class TestLamda1 {    //3. 静态内部类    static class Like2 implements ILike{        @Override        public void lambda() {            System.out.println("I like 兔子2");        }    }    public static void main(String[] args) {        ILike like = new Like();        like.lambda();        like = new Like2();        like.lambda();        //4. 局部内部类        class Like3 implements ILike{            @Override            public void lambda() {                System.out.println("I like 兔子3");            }        }        like = new Like3();        like.lambda();        //5. 匿名内部类,没有类的名称，必须借助接口或者父类        like = new ILike() {            @Override            public void lambda() {                System.out.println("I like 兔子4");            }        };        like.lambda();        //6. 用lambda简化        like =() ->{            System.out.println("I like 兔子5");        };        like.lambda();    }}//1. 定义一个函数式接口interface ILike{    void lambda();}//2. 实现类class Like implements ILike{    @Override    public void lambda() {        System.out.println("I like 兔子");    }}

• 理解Functional interface(函数式接口)是学习Java 8 Lambda表达式的关键所在

• 函数式接口的定义：

  • 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口。

    public interface Runnable{  public abstract void run();}
    

  • 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

03线程状态

五个状态

方法	说明
setPriority(int newPriority)	更改线程优先级
static void sleep( long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	插队？等待该线程终止？
static void yield()	暂停当前正在执行的线程对象,并执行其他线程
void interrupt()	中断线程,别用这个方式
boolean isAliveo()	测试线程是否处于活动状态

1.1、线程停止-Stop

不建议使用JDK提供的stop()、destray()方法，废弃

推荐线程自己停止下来

建议使用一个标志位进行终止变量当flag=false，则终止线程运行。

//标识终止：private boolean flag = true; @Overridepublic void run(){	while(flag){		System.out.println("run...Thread");	}}//提供方法改变标识public void stop(){	this.flag = false;}

package rabbit.demo04;/*线程停止测试Stop *///1.建议线程正常停止--->利用次数，不建议死循环//2.建议使用标志符--->设置一个标志//3.不要使用stop或者destroy等过时或者JDK不建议使用方法public class TestStop implements Runnable{    //1.设置一个标志位    private boolean flag = true;    @Override    public void run() {        int i = 0;        while (flag){            System.out.println("run...Thread"+i++);        }    }    //2.设置一个公开的方法停止线程，转换标志位    public void stop(){        this.flag = false;    }    public static void main(String[] args) {        TestStop testStop = new TestStop();        new Thread(testStop).start();        for (int i = 0; i < 1000; i++) {            System.out.println("main"+i);            if (i==900){                //调用stop方法切换标志位，让线程停止                testStop.stop();                System.out.println("该线程停止了");            }        }    }}

1.2、线程休眠-Sleep

• sleep(时间)指定当前线程阻塞的毫秒数（1000毫秒=1秒）
• sleep存在异常InterruptedException;（需要抛出）
• sleep时间走完线程进入就绪状态
• sleep可以模拟网络延迟，倒计时等
• 每个对象都有一把锁，sleep不会释放锁

package rabbit.demo04;//模拟倒计时public class TestSleep2 {    public static void main(String[] args) {        try {            tenDown();        } catch (InterruptedException e) {            e.printStackTrace();        }    }    public static void tenDown() throws InterruptedException {        int num = 10;        while (true){            Thread.sleep(1000);            System.out.println(num--);            if (num<=0){                break;            }        }    }}

//模拟倒计时public class TestSleep2 {    public static void main(String[] args) {        //打印当前系统时间        Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间        while(true){            try {                Thread.sleep(1000);                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));                startTime = new Date(System.currentTimeMillis());            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }    public static void tenDown() throws InterruptedException {        int num = 10;        while (true){            Thread.sleep(1000);            System.out.println(num--);            if (num<=0){                break;            }        }    }}

1.3、线程礼让-Yield

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

package rabbit.demo04;import rabbit.demo01.TestThread1;//测试礼让线程//礼让不一定成功，主要看CPU心情public class TestYield {    public static void main(String[] args) {        MyYield myYield = new MyYield();        new Thread(myYield,"a").start();        new Thread(myYield,"b").start();    }}class MyYield implements Runnable{    @Override    public void run() {        System.out.println(TestThread1.currentThread().getName()+"线程开始执行");        Thread.yield();//礼让        System.out.println(TestThread1.currentThread().getName()+"线程停止执行");    }}

1.4、线程强制执行-Join

无比霸道，🌤强线程所难！

Join合并线程，😳待此线程执行完后，再执行其他线程，其他线程阻塞

可以想象成插队！真坏！

package rabbit.demo04;//测试Join方法，就是插队public class TestJoin implements Runnable {    @Override    public void run() {        for (int i = 0; i < 1000; i++) {            System.out.println("线程VIP来了"+i);        }    }    public static void main(String[] args) throws InterruptedException {       TestJoin testJoin = new TestJoin();       Thread thread = new Thread(testJoin);       thread.start();       //主线程        for (int i = 0; i < 500; i++) {            if (i==200){                thread.join();//插队            }            System.out.println("main"+i);        }    }}

1.5、线程状态观测-Stata

查看JDK帮助文档：搜索Thread.State

• 线程状态。线程可以处于以下状态之一：

  • NEW
    尚未启动的线程处于此状态。
  • RUNNABLE
    在Java虚拟机中执行的线程处于此状态。
  • BLOCKED
    被阻塞等待监视器锁定的线程处于此状态。
  • WAITING
    正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED
    已退出的线程处于此状态。

  一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

//观察测试线程的状态public class TestState {    public static void main(String[] args) throws InterruptedException {        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 state = thread.getState();        System.out.println(state); //NEW        //观察启动后        thread.start(); //启动线程        state = thread.getState();        System.out.println(state); //Run        while(state != Thread.State.TERMINATED){ //只要线程不终止，就一直输出状态            Thread.sleep(100);            state = thread.getState(); //更新线程状态            System.out.println(state); //输出状态        }    }}

1.6、线程优先级

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用，这都是看CPU心情来调度的

• Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。

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

  • Thread . MIN_PRIORTY=1
  • Thread . MAX_PRIORITY=10
  • Thread . NORM_Priority= 5

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

  • getPriority();
  • setPriority(int xx×);

• 优先级的设定建议在start()调度前

package rabbit.demo04;//测试线程优先级public class TestPriority extends Thread{    public static void main(String[] args) {        //主线程默认优先级        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());        Mypriority mypriority = new Mypriority();        Thread t1 = new Thread(mypriority);        Thread t2 = new Thread(mypriority);        Thread t3 = new Thread(mypriority);        Thread t4 = new Thread(mypriority);        Thread t5 = new Thread(mypriority);        Thread t6 = new Thread(mypriority);        //先设置优先级，再启动        t1.start();        t2.setPriority(1);        t2.start();        t3.setPriority(4);        t3.start();        t4.setPriority(Thread.MAX_PRIORITY); //MAX_PRIORITY=10        t4.start();//        t5.setPriority(-1);//        t5.start();        t6.setPriority(11);//        t6.start();    }}class Mypriority implements Runnable{    @Override    public void run() {        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());    }}

1.7、守护线程-daemon

线程分为用户线程和守护线程

用户线程：例如main；（虚拟机必须确保用户线程执行完毕）

守护线程：例如gc；（虚拟机不用等待守护线程执行完毕）

如，后台操作日志，监控内存，立即回收等待…

package rabbit.demo04;public class TestDaemon {    public static void main(String[] args) {        God god = new God();        You you = new You();        Thread thread = new Thread(god);        thread.setDaemon(true); //默认是false表示是用户线程，正常的线程都是用户线程...        thread.start(); //上帝启动神圣之光        new Thread(you).start(); //你 用户线程启动    }}//上帝class God implements Runnable{    @Override    public void run() {        while (true){            System.out.println("神圣之光");        }    }}//你class You implements Runnable{    @Override    public void run() {        for (int i = 0; i < 36500; i++) {            System.out.println("你一生快乐顺遂！");        }        System.out.println("=====Goodbye!World!====="); //Hello,World!    }}

04线程同步

多个线程操作同一个资源；同一个对象被多个线程同时操作：并发

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

队列和锁

队列+锁才能保证线程同步的安全性，解决线程不安全的问题，又叫线程同步锁机制synchronized

每个对象都有一把锁，sleep不会释放锁

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

1.1、三大不安全例子

买火车票

package rabbit.demo05;//不安全的买票//线程不安全有负数public class UnsafeBuyTicket {    public static void main(String[] args) {        Buysticket station = new Buysticket();        new Thread(station,"韩韩").start();        new Thread(station,"小兔").start();        new Thread(station,"🐢").start();    }}class Buysticket implements Runnable{    //票    private int ticketNums = 10;    boolean flag = true; //外部停止方式    @Override    public void run() {        //买票        while (flag){            buy();        }    }    private void buy(){        //判断是否有票        if (ticketNums<=0){            flag = false;            return;        }        //模拟延时        try {            Thread.sleep(100);        } catch (InterruptedException e) {            e.printStackTrace();        }        //买票        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);    }}

取钱

package rabbit.demo05;//不安全的取钱//两个人去银行取钱public class UnsafeBank {    public static void main(String[] args) {        //账户        Account account = new Account(100,"兔兔基金");        Drawing you = new Drawing(account,50,"小兔");        Drawing wife = new Drawing(account,100,"韩韩");        you.start();        wife.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(Thread.currentThread().getName()+"你没钱啦！");            return;        }        //sleep可放大问题的发生性        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        //卡内余额 = 余额 - 你取的钱        account.money = account.money-drawingMoney;        //你手里的钱        nowMoney = nowMoney + drawingMoney;        System.out.println(account.name+"余额为："+account.money);        //Thread.currentThread().getName()等价于this.getName()        System.out.println(this.getName()+"手里的钱："+nowMoney);    }}

📕线程数组

package rabbit.demo05;import java.util.ArrayList;import java.util.List;//线程不安全的集合public class UnsafeList {    public static void main(String[] args) {        List<String> list = new ArrayList<>();        for (int i = 0; i < 10000; i++) {            new Thread(()->{                list.add(Thread.currentThread().getName());            }).start();        }        try {            Thread.sleep(3000);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(list.size());    }}

1.2、同步方法

• 由于我们可以通过 private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法：synchronized方法 和 synchronized块

  ​ 同步方法: public synchronized void method(int args){}

• synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行

  ​ 缺陷:若将一个大的方法申明为 synchronized将会影响效率

同步方法弊端：

• 方法里面需要修改内容才需要锁，锁的太多，浪费资源

同步块（锁）：synchronized (Obj) { }需要监视的对象，就是需要增删改插的对象

• Obj称之为同步监视器
• Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
• 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者class（反射中以后会讲）

同步监视器的执行过程

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

package rabbit.demo05;import java.util.ArrayList;import java.util.List;//线程不安全的集合public class UnsafeList {    public static void main(String[] args) {        List<String> list = new ArrayList<>();        for (int i = 0; i < 10000; i++) {            new Thread(()->{                synchronized (list){//list变量做添加操作，所以把list锁住                    list.add(Thread.currentThread().getName());                }            }).start();        }        try {            Thread.sleep(3000);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(list.size());    }}

测试JUC并发包安全类集合

import java.util.concurrent.CopyOnWriteArrayList;//测试JUC安全类型的集合public class TestJUC {    public static void main(String[] args) {        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();        for (int i = 0; i <10000; i++) {            new Thread(()->{                list.add(Thread.currentThread().getName());            }).start();        }        try {            Thread.sleep(3000);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println(list.size());    }}

1.3、死锁

多个线程互相抱着对方需要的资源，然后形成僵持

多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或 者多个线程都在等待对方释放资源,都停止执行的情形.某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。

死锁的避免方法

产生死锁的四个必要条件

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

package rabbit.demo05;//死锁：多个线程互相抱着对方需要的资源，然后形成僵持。public class DeadLock {    public static void main(String[] args) {        Makeup n1 = new Makeup(0,"灰姑娘");        Makeup n2 = new Makeup(0,"坏坏的后妈");        n1.start();        n2.start();    }}//💄口红class Lipstick{}//镜子class Mirror{}class Makeup extends Thread{    //需要的资源只有一份，用static来保证只有一份    static Lipstick lipstick = new Lipstick();    static Mirror mirror = new Mirror();    int choice; //选择    String name; //使用化妆品的人    Makeup(int choice,String name){        this.choice =choice;        this.name = name;    }    @Override    public void run() {        //化妆        try {            makeup();        } catch (InterruptedException e) {            e.printStackTrace();        }    }    //化妆，互相持有对方的锁，就是需要拿到对方的资源    private void makeup() throws InterruptedException {        if (choice==0){            synchronized (lipstick){ //获得口红的锁                System.out.println(this.name+"获得口红的锁");                Thread.sleep(1000);            }            synchronized (mirror){ //一秒钟后想获得镜子                System.out.println(this.name+"获得镜子的锁");            }        }else {            synchronized (mirror){ //获得镜子的锁                System.out.println(this.name+"获得镜子的锁");                Thread.sleep(2000);            }            synchronized (lipstick){ //一秒钟后想获得口红                System.out.println(this.name+"获得口红的锁");            }        }    }}

1.4、Lock（锁）

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

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，县城开始访问共享资源之前应先获得Lock对象

ReentranLock（可重入锁）类实现了Lock，它拥有了与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是Reentrantlock,可以显式加锁、释放锁。

package rabbit.demo05;import java.util.concurrent.locks.ReentrantLock;//测试Lock锁public class TestLock {    public static void main(String[] args) {        TestLock2 testLock2 = new TestLock2();        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();    @Override    public void run() {        while (true){            try {                lock.lock(); //加锁                if (ticketNums>0){                    try {                        Thread.sleep(1000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(ticketNums--);                }else {                    break;                }            } finally {                //解锁                lock.unlock();            }        }    }}

synchronized与lock的区别

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

05线程协作

生产者消费者模式

---

1.1、线程通信

应用场景:生产者和消费者问

• 假设仓库中只能存放- -件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费.

• 如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止.

• 如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待，直到仓库中再次放入产品为止.

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

• 对于生产者,没有生产产品之前,要通知消费者等待.而生产了产品之后，又需要马上通知消费者消费

• 对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费.

• 在生产者消费者问题中, 仅有synchronized是不够的

• • synchronized 可阻止并发更新同一个共享资源，实现了同步
  • synchronized不能用来实现不同线程之间的消息传递(通信)

解决方式 1管程法.

并发写作模型“生产者/消费者模式”—>管程法

• 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）；

• 消费者:负责处理数据的模块（科能是方法，对象，线程，进程）；

• 缓冲区：消费者不能直接使用生产者数据，他们之间有一个“缓冲区”；

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

notifyAll唤醒进入这个对象的线程，通知所有

package rabbit.demo06;//测试：测试生产者消费者模型--->利用缓冲区解决：管程法//生产者、消费者、产品、缓冲区//农夫生产胡萝卜，🐇吃🥕public class TestPC {    public static void main(String[] args) {        SynContainer container = new SynContainer(); //缓冲区        new Farmer(container).start(); //生产者线程开启        new Rabbit(container).start(); //消费者线程开启    }}//农夫class Farmer extends Thread{    SynContainer container;    public Farmer(SynContainer container){        this.container = container;    }    //种🥕    @Override    public void run() {        for (int i = 0; i < 50; i++) {            container.push(new Carrot(i));            System.out.println("种出来了"+i+"根🥕");        }    }}//兔子class Rabbit extends Thread{    SynContainer container;    public Rabbit(SynContainer container){        this.container = container;    }    //消费    @Override    public void run() {        for (int i = 0; i < 50; i++) {            System.out.println("兔子吃完了"+container.pop().id+"根🥕");        }    }}//🥕class Carrot{    int id; //🥕的编号    public Carrot(int id) {        this.id = id;    }}//缓冲区class SynContainer {    //需要一个篮子大小    Carrot[] carrots = new Carrot[10];    //容器计数器    int count = 0;    //农夫放入胡萝卜    public synchronized void push(Carrot carrot){        //如果篮子满了就需要等待🐇来吃        if (count==carrots.length){            //通知🐇来吃，农夫等待兔子吃了再生产            //通知消费者消费，生产等待            try {                wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        //如果没有满，就需要丢入🥕        carrots[count] = carrot;        count++;        //可以通知兔子来吃了        this.notifyAll();    }    //兔子吃🥕    public synchronized Carrot pop(){        //判断有没有🥕可以吃        if(count==0){            //等待农夫生产，🐇等待        }        //如果有🥕吃        count--;        Carrot carrot = carrots[count];        //吃完了，通知农夫种🥕        this.notifyAll();        return carrot;    }}

解决方式 2信号灯法

并发写作模型“生产者/消费者模式”—>信号灯法

package rabbit.demo06;//“生产者/消费者模式”--->信号灯法，标志位解决public class TestPC2 {    public static void main(String[] args) {     TV tv = new TV();     new Actor(tv).start();     new Audience(tv).start();    }}//生产者-->演员class Actor extends Thread{    TV tv;    public Actor(TV tv){        this.tv = tv;    }    @Override    public void run() {        for (int i = 0; i < 20; i++) {            if (i%2==0){                this.tv.play("快乐大本营播放中！");            }else {                this.tv.play("抖音记录美好生活！");            }        }    }}//消费者-->观众class Audience extends Thread{    TV tv;    public Audience(TV tv){        this.tv = tv;    }    @Override    public void run() {        for (int i = 0; i < 20; i++) {            tv.watch();        }    }}//产品-->节目class TV{    //演员表演，观众等待    //观众观看，演员等待    String voice; //表演节目    boolean flag = true;    //表演    public synchronized void play(String voice){        if (!flag){            try {                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        System.out.println("演员表演了："+voice);        //通知观众观看        this.notifyAll();//通知唤醒        this.voice = voice;        this.flag = !this.flag;    }    //看    public synchronized void watch(){        if (flag){            try {                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        System.out.println("观看了："+voice);        //通知演员表演        this.notifyAll();        this.flag = !this.flag;    }}

1.2、使用线程池

背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路:提前创建好多个线程,放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用类似生活中的公共交通工具。

• 好处:
  提高响应速度(减少了创建新线程的时间)
  降低资源消耗(重复利用线程池中线程，不需要每次都创建)
• 便于线程管理(…）
  • corePoolSize:核心池的大小
    maximumPoolSize: 最大线程数
    keepAliveTime:线程没有任务时最多保持多长时间后会终止

JDK 5.0起提供了线程池相关API: ExecutorService 和Executors

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

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

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

• void shutdown()关闭连接池

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

package rabbit.demo06;import java.lang.reflect.Executable;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;//测试线程池public class TestPool {    public static void main(String[] args) {        //1.创建服务，创建线程池        //newFixedThreadPool参数：为线程池的大小        ExecutorService service = Executors.newFixedThreadPool(10);        //执行        service.execute(new MyThread());        service.execute(new MyThread());        service.execute(new MyThread());        service.execute(new MyThread());        //2， 关闭连接        service.shutdown();    }}class MyThread implements Runnable{    @Override    public void run() {        for (int i = 0; i < 100; i++) {            System.out.println(Thread.currentThread().getName()+i);        }    }}

总结：