多线程笔记

1、线程简介

核心概念

介绍多线程之前要介绍线程，介绍线程则离不开进程。首先 :
　　进程：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元；
　　线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。
　　多线程：一个进程中不只有一个线程。

为什么要用多线程：
　　　　①、为了更好的利用cpu的资源，如果只有一个线程，则第二个任务必须等到第一个任务结束后才能进行，如果使用多线程则在主线程执行任务的同时可以执行其他任务，而不需要等待；
　　　　②、进程之间不能共享数据，线程可以；
　　　　③、系统创建进程需要为该进程重新分配系统资源，创建线程代价比较小；
　　　　④、Java语言内置了多线程功能支持，简化了java多线程编程。

2、线程实现（重点）

三种创建方式：

1、Thread Class ：继承Thread Class（重点）

调用run()方法，只有主线程一条执行路径。

调用start()方法，多条执行路径，主线程和子线程并行交替执行。

请添加图片描述

代码实现：

package com.it.che.thread;

public class TheradTest1 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线程，主线程
        //创建一个线程对象
        TheradTest1 theradTest1 = new TheradTest1();
        //调用run()方法
        theradTest1.run();
        //调用start()方法开启线程
        //theradTest1.start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程-->"+i);
        }
    }

}

1、调用run()方法运行结果如下：
请添加图片描述
2、调用start()方法运行结果如下：

练习Thread ，实现多线程同步下载图片

package com.it.che.thread;

import org.apache.commons.io.FileUtils;

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

//练习Thread ，实现多线程同步下载图片
public class ThreadTest2 extends Thread{
    private String url;//网络图片地址
    private String name;//保存的文件名

    public ThreadTest2(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.downLoader(url,name);
        System.out.println("下载了文件名为："+name);
    }

    public static void main(String[] args) {
        ThreadTest2 t1 = new ThreadTest2("https://tse1-mm.cn.bing.net/th/id/R-C.e30ac0a9f025aa579f8c1670386fdec1?rik=hgqrwPy%2f%2byJjdg&riu=http%3a%2f%2fimg.ewebweb.com%2fuploads%2f20191225%2f19%2f1577274336-WEAqckJYeu.jpeg&ehk=heJB%2bNKArCteUSuTtpAZEMIHHhJvxcwO%2bk8hXU5ePNg%3d&risl=&pid=ImgRaw&r=0","1.jpg");
        ThreadTest2 t2 = new ThreadTest2("https://tse4-mm.cn.bing.net/th/id/OIP-C.sPROob9-gFtRkbZlWpVjvQHaHa?pid=ImgDet&rs=1","2.jpg");
        ThreadTest2 t3 = new ThreadTest2("https://tse1-mm.cn.bing.net/th/id/R-C.171e8fe1aa1544a1868ab710eed82d82?rik=FLPxvVVL9C9bnQ&riu=http%3a%2f%2fwww.pp3.cn%2fuploads%2fallimg%2f200710%2f14-200G00Z321.jpg&ehk=Lb0IHCCZIdqYQOi28m%2borU8c1ARGbTEC%2f8WYzfwRuHo%3d&risl=&pid=ImgRaw&r=0","3.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}

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

运行结果如下：
在这里插入图片描述
2、Runnable接口：实现Runnable接口（重点）
（1）、抢票问题–>并发问题：
代码实现如下：

package com.it.che.thread;
/*
多线程的创建方式二：实现Runnable接口
 */
//抢票问题-->并发问题
public class ThreadTest3 implements Runnable{
    //票数
    private int tickets = 20 ;

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

    public static void main(String[] args) {
        ThreadTest3 threadTest3 = new ThreadTest3();
        new Thread(threadTest3,"小明").start();
        new Thread(threadTest3,"老师").start();
        new Thread(threadTest3,"黄牛党").start();
    }
}

运行结果如下：
在这里插入图片描述
（2）、龟兔赛跑—>模拟兔子睡觉
代码实现如下：

package com.it.che.thread;
//模拟龟兔赛跑
public class ThreadTest4 implements Runnable{
    //胜利者
    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 200; i++) {
            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子") && i%50==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            Boolean flag = gamaOver(i);
            //如果比赛结束了就停止
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步");
        }


    }
    //判断是否完成比赛
    private boolean gamaOver(int steps){
        //判断是否有胜利者
       if (winner != null){//已经存在胜利者了
           return true;
       }{
           if (steps >= 200){
               winner = Thread.currentThread().getName();
               System.out.println("Winner is --->"+winner);
               return true;
           }
        }
       return false;
    }

    public static void main(String[] args) {
        ThreadTest4 threadTest4 = new ThreadTest4();
        new Thread(threadTest4,"兔子").start();
        new Thread(threadTest4,"乌龟").start();
    }
}

运行结果如下：
在这里插入图片描述
3、Callable接口：实现Callable接口（了解）
步骤：

1、创建执行服务

ExecutorService ser = Executors.newFixedThreadPool(3);

2、提交执行

Future<Boolean> s1 = ser.submit(t1);

3、获取结果

Boolean aBoolean1 = s1.get();

4、关闭服务

ser.shutdown();

代码演示如下：

package com.it.che.thread;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

public class ThreadTest5 implements Callable<Boolean> {
    private String url;//网络图片地址
    private String name;//保存的文件名
    public ThreadTest5(String url, String name) {
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call() throws Exception {
        webDownLoader webDownLoader = new webDownLoader();
        webDownLoader.downLoader(url,name);
        System.out.println("下载了文件名为："+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadTest5 t1 = new ThreadTest5("https://tse1-mm.cn.bing.net/th/id/R-C.e30ac0a9f025aa579f8c1670386fdec1?rik=hgqrwPy%2f%2byJjdg&riu=http%3a%2f%2fimg.ewebweb.com%2fuploads%2f20191225%2f19%2f1577274336-WEAqckJYeu.jpeg&ehk=heJB%2bNKArCteUSuTtpAZEMIHHhJvxcwO%2bk8hXU5ePNg%3d&risl=&pid=ImgRaw&r=0","1.jpg");
        ThreadTest5 t2 = new ThreadTest5("https://tse1-mm.cn.bing.net/th/id/R-C.171e8fe1aa1544a1868ab710eed82d82?rik=FLPxvVVL9C9bnQ&riu=http%3a%2f%2fwww.pp3.cn%2fuploads%2fallimg%2f200710%2f14-200G00Z321.jpg&ehk=Lb0IHCCZIdqYQOi28m%2borU8c1ARGbTEC%2f8WYzfwRuHo%3d&risl=&pid=ImgRaw&r=0","2.jpg");
        ThreadTest5 t3 = new ThreadTest5("https://tse4-mm.cn.bing.net/th/id/OIP-C.sPROob9-gFtRkbZlWpVjvQHaHa?pid=ImgDet&rs=1","3.jpg");
        //1、创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //2、提交执行
        Future<Boolean> s1 = ser.submit(t1);
        Future<Boolean> s2 = ser.submit(t2);
        Future<Boolean> s3 = ser.submit(t3);
        //3、获取结果
        Boolean aBoolean1 = s1.get();
        Boolean aBoolean2 = s2.get();
        Boolean aBoolean3 = s3.get();
        //4、关闭服务
        ser.shutdown();
    }
}
class webDownLoader {
    public void downLoader(String url ,String name) throws IOException {
        FileUtils.copyURLToFile(new URL(url),new File(name));
    }
}

运行结果如下：
在这里插入图片描述
静态代理模式总结：
1、真实对象和代理对象都要实现同一个接口
2、代理对象要代理真实角色
好处：
1、代理对象可以做很多真实对象做不了的事情
2、真实对象专注做自己的事情
代码实现如下：

public class StaticProxy {
 public static void main(String[] args) {
     new Thread( ()-> System.out.println("我爱你")).start();

     new Wedding(new You()).HappyMarry();
 }
}
interface Marry{
 void HappyMarry();
}
//真实角色，你去结婚
class You implements Marry{

 @Override
 public void HappyMarry() {
     System.out.println("车老师要结婚了，超开心");
 }
}
//代理角色，帮助你结婚
class Wedding implements Marry{
 private Marry target;

 public Wedding(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("结婚之前，布置现场");
 }
}

Lamda表达式定义：

	1、避免匿名内部类定义过多；
	2、可以让你的代码看起来很简洁；
	3、去掉一堆没有意义的代码，只留下核心逻辑。

函数式接口：

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

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

2、对于函数式接口，我们可以使用lambda表达式来创建该接口的对象。

示例代码如下：

public class LambdaTest1 {
    //3、静态内部类
    static class Like3 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like Lambda3");
        }
    }
    public static void main(String[] args) {

        ILike iLike = new Like2();
        iLike.lambda();

        iLike = new Like3();
        iLike.lambda();

        //4、局部内部类
        class Like4 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like Lambda4");
            }
        }
        iLike = new Like4();
        iLike.lambda();

        //5、匿名内部类，没有类的名称，必须借助接口或者父类
        iLike = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like Lambda5");
            }
        };
        iLike.lambda();

        //6、使用lambda简化
        iLike = ()->{ System.out.println("I like Lambda6");};
        iLike.lambda();
    }
}
//1、定义一个函数式接口
interface ILike{
    void lambda();
}
//2、实现类
class Like2 implements ILike{

    @Override
    public void lambda() {
        System.out.println("I like Lambda2");
    }
}

运行结果如下：
在这里插入图片描述
Lambda表达式的简化：
示例代码如下：

package com.it.che.day2.Demo01;
public class LambdaTest2 {
    public static void main(String[] args) {
        Love love = null;
        //1、使用lambda表达式简化
        /*love = (int a , int b )->{
            System.out.println("I Love You -->"+a);
        };
        love.iLove(520);*/

        //2、简化Lambda表达式-->去掉返回值类型
        /*love = (int a , int b)->{
            System.out.println("I Love You -->"+a);
        };
        love.iLove(520);*/

        //3、简化Lambda表达式-->去掉小括号（）
        love = (a , b)->{
            System.out.println("I Love You -->"+a);
            System.out.println("I Love You -->"+b);
        };
        love.iLove(520,521);

        //4、简化Lambda表达式-->去掉大括号{}（只有里面只有一句，才能去掉大括号{}）
        /*love = (a , b)-> System.out.println("I Love You -->"+a);
        love.iLove(520,521);*/
/*
总结：
 1、Lambda表达式只能有一行代码的情况下才能简化成去掉{}；
 2、必须是接口为函数式接口（接口里面只有一个方法）；
 3、多个参数也可以去掉参数类型，多个参数类型要都去掉,必须要用小括号()包住；
*/
    }
}
interface Love{
    void iLove(int a , int b);
}

总结：

1、Lambda表达式只能有一行代码的情况下才能简化成去掉{}；
2、必须是接口为函数式接口（接口里面只有一个方法）；
3、多个参数也可以去掉参数类型，多个参数类型要都去掉,必须要用小括号()包住；

3、线程状态

在这里插入图片描述
详细来说的话：

线程的相关方法：

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

停止线程：

1、不推荐使用JDK提供的stop()、destroy()方法。【已废弃】
2、推荐线程自己停止下来。
3、建议使用一个标志位进行终止变量当flag=false，则终止线程运行。

代码测试如下：

package com.it.che.day2.Demo01;
/*
1、不推荐使用JDK提供的stop()、destroy()方法。【已废弃】
2、推荐线程自己停止下来。
3、建议使用一个标志位进行终止变量当flag=false，则终止线程运行。
 */
public class ThreadStopTest 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 myStop(){
        this.flag = false;
    }
    
    public static void main(String[] args) {
        ThreadStopTest threadStopTest = new ThreadStopTest();
        new Thread(threadStopTest).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main-->"+i);
            if (i == 900){
                //调用myStop方法，切换标志位，让线程停止
                threadStopTest.myStop();
                System.out.println("线程该停止了");
            }
        }
    }
}

运行结果如下：
在这里插入图片描述
线程休眠：

1、sleep存在异常InterruptedException；
2、sleep时间达到后，线程进入就绪状态；
3、每一个对象都有一个锁，sleep不会释放锁。

代码演示线程休眠（倒计时和获取当前时间）

package com.it.che.day2.Demo01;

import java.text.SimpleDateFormat;
import java.util.Date;
线程休眠：
1、sleep存在异常InterruptedException；
2、sleep时间达到后，线程进入就绪状态；
3、每一个对象都有一个锁，sleep不会释放锁。
 */
public class ThreadSleepTest {
    private boolean flag = true ;
    public static void main(String[] args) throws InterruptedException {
        //timeDown();
        thisTime();

    }

    //模拟倒计时
    public static void timeDown() throws InterruptedException {
        int num = 10 ;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
    //模拟获取当前时间
    public static void thisTime() throws InterruptedException {
        //获取当前系统时间
        Date date = new Date(System.currentTimeMillis());
        for (int i = 0; i < 10; i++) {
            while (i>=10){
                break;
            }
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            //更新当前系统时间
            date = new Date(System.currentTimeMillis());
        }

    }

    public void myStop(){
        this.flag = false;
    }

}

运行结果如下：
在这里插入图片描述
线程礼让：

1、礼让线程，让当前正在执行的线程暂停，但不阻塞；
2、让线程从运行状态转换为就绪状态；
3、让CPU重新调度，礼让不一定成功，看cpu心情。

package com.it.che.day2.Demo01;
/*
线程礼让
    1、礼让线程，让当前正在执行的线程暂停，但不阻塞；
    2、让线程从运行状态转换为就绪状态；
    3、让CPU重新调度，礼让不一定成功，看cpu心情。
 */
public class ThreadYieldTest {
    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(Thread.currentThread().getName()+"线程开始执行");
        //线程礼让(礼让不一定成功)
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程执行结束");
    }
}

运行结果如下：
在这里插入图片描述
Join合并线程：

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

package com.it.che.day2.Demo01;
/*
Join合并线程：
    Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
 */
public class ThreadJoinTest implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("Vip线程进来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动线程
        ThreadJoinTest threadJoinTest = new ThreadJoinTest();
        Thread thread = new Thread(threadJoinTest);
        thread.start();
        //主线程
        for (int i = 0; i < 200; i++) {
            if (i == 50){
                thread.join();
            }
            System.out.println("main-->"+i);
        }
    }
}

执行结果如下：
在这里插入图片描述
线程的状态观测：

Thread.State
    1、NEW
    尚未启动的线程处于此状态；
    2、RUNNABLE
    在Java虚拟机中执行的线程处于此状态；
    3、BLOCKED
    被阻塞等待监视器锁定的线程处于此状态；
    4、WAITING
    正在等待另一个线程执行特定动作的线程处于此状态；
    5、TIMED-WAITING
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态；
    6、TERMINATED
    已退出的线程处于此状态；
一个线程可以在给定时间点处于一个状态。这些状态是不反应任何操作系统线程状态的虚拟机状态。

代码实现如下：

package com.it.che.day2.Demo01;
/*
线程状态观测：
Thread.State
    1、NEW
    尚未启动的线程处于此状态；
    2、RUNNABLE
    在Java虚拟机中执行的线程处于此状态；
    3、BLOCKED
    被阻塞等待监视器锁定的线程处于此状态；
    4、WAITING
    正在等待另一个线程执行特定动作的线程处于此状态；
    5、TIMED-WAITING
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态；
    6、TERMINATED
    已退出的线程处于此状态；
一个线程可以在给定时间点处于一个状态。这些状态是不反应任何操作系统线程状态的虚拟机状态。
 */
public class ThreadStateTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("------/--------");
        });
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);

        thread.start();
        state = thread.getState();
        System.out.println(state);

        //只要线程不终止，就一直输出状态
        while (state!= Thread.State.TERMINATED){
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

运行结果如下：
在这里插入图片描述
线程优先级：

1、Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行；
2、线程的优先级用数字表示，范围从1~10；
    Thread.MIN_PRIORITY = 1 ;
    Thread.MAX_PRIORITY = 10 ;
    Thread.NORM_PRIORITY = 5 ;
3、使用以下方式改变或获取线程优先级
    getPriority().setPriority(int **)

代码演示如下：

package com.it.che.day2.Demo01;
/*
线程优先级：
    1、Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行；
    2、线程的优先级用数字表示，范围从1~10；
        Thread.MIN_PRIORITY = 1 ;
        Thread.MAX_PRIORITY = 10 ;
        Thread.NORM_PRIORITY = 5 ;
    3、使用以下方式改变或获取线程优先级
        getPriority().setPriority(int **)
 */
public class ThreadPriorityTest {
    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(Thread.MIN_PRIORITY);//MIN_PRIORITY==1
        t2.start();

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

        t4.setPriority(8);
        t4.start();

        t5.setPriority(7);
        t5.start();

        t6.setPriority(6);
        t6.start();
    }
}
class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

运行结果如下：
可见，虽然设置了优先级，但是线程的执行顺序还是按照cpu的调度来进行。
但是在一定程度上，优先级高的线程，越早执行。
在这里插入图片描述
守护线程:

    1、线程分为用户线程和守护线程；
    2、虚拟机必须确保用户线程执行完毕；
    3、虚拟机不用等待守护线程执行完毕；
    4、如：后台记录操作日志，监控内存，垃圾回收等待...

代码演示如下：

package com.it.che.day2.Demo01;
/*
守护线程:
    1、线程分为用户线程和守护线程；
    2、虚拟机必须确保用户线程执行完毕；
    3、虚拟机不用等待守护线程执行完毕；
    4、如：后台记录操作日志，监控内存，垃圾回收等待...
 */
public class ThreadDaemonTest {
    public static void main(String[] args) {
        God god = new God();
        My my = new My();

        Thread thread = new Thread(god);
        //默认是false表示用户线程，正常的线程都是用户线程。
        thread.setDaemon(true);
        //上帝守护线程启动
        thread.start();
        new Thread(my).start();
    }

}
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝守护着你");
        }
    }
}
class My implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都在开心的活着");
        }
        System.out.println("-------------goodbye! world!--------------");
    }
}

运行结果如下：
在这里插入图片描述

4、线程同步（重点）

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

线程同步：

同步方法：

同步方法弊端：

同步块：

三大不安全实例：
1、三大不安全实例—买票

package com.it.che.day2.Demo02;
/**
 * @简单描述：三大不安全实例---买票
 */
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();
        new Thread(buyTickets,"路人甲").start();
        new Thread(buyTickets,"路人乙").start();
        new Thread(buyTickets,"黄牛党").start();
    }

}
class BuyTickets implements Runnable{
    private int ticketsNum = 10 ;
    boolean flag = true ;
    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    void buy() throws InterruptedException {
        //判断是否有票
        if (ticketsNum <= 0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"拿到了"+ticketsNum--);
    }
}

运行结果如下：
在这里插入图片描述
2、三大不安全实例之二----取钱

package com.it.che.day2.Demo02;

/**
 * @简单描述：三大不安全实例之二----取钱
 */
public class UnSafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing my = new Drawing(account,50,"我");
        Drawing girlFriend = new Drawing(account,100,"girlFriend");

        my.start();
        girlFriend.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){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不到");
            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(this.getName()+"手里的钱："+nowMoney);
    }
}

运行结果如下：
在这里插入图片描述
3、三大不安全实例之三----集合

package com.it.che.day2.Demo02;
import java.util.ArrayList;
import java.util.List;

/**
 * @简单描述：三大不安全实例之三----集合
 */
public class UnSafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 30000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        //Thread.sleep(3000);
        System.out.println(list.size());
    }
}

运行结果如下：
在这里插入图片描述
测试JUC安全类型的集合
代码演示如下：

package com.it.che.thread;

import java.util.concurrent.CopyOnWriteArrayList;

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

运行结果如下：
在这里插入图片描述
死锁：

死锁避免方法：

代码演示死锁：

package com.it.che.thread;

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 Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int id;
    String girlName;

    Makeup(int id , String girlName){
        this.id = id ;
        this.girlName = girlName ;
    }

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

    //化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (id == 0){
            synchronized (lipstick){
                System.out.println(this.girlName+"获得口红的锁");
                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+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
            /*synchronized (lipstick){
                System.out.println(this.girlName+"获得口红的锁");
            }*/
        }
    }
}

运行结果如下：
在这里插入图片描述
Lock(锁)

代码演示如下：

package com.it.che.lock;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
            BuyTickets buyTickets = new BuyTickets();
            new Thread(buyTickets).start();
            new Thread(buyTickets).start();
            new Thread(buyTickets).start();
    }

}
class BuyTickets implements Runnable{
    int ticketsNum = 10 ;
    //定义lock锁
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                lock.lock(); //加锁
                if (ticketsNum>0){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketsNum--);
                }else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }

        }
    }
}

运行结果如下：
在这里插入图片描述
synchronized 与 Lock的对比

5、线程通信问题

生产者消费者模式

线程通信-分析

解决方式：

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

方法名	作用
wait()	表示线程一直等待,直到其他线程通知，与sleep不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

注意:均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常llIlegalMonitorStateException

6、高级主题

线程池：

package com.it.che.lock;

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

//测试线程池
public class ThreadPoolTest {
    public static void main(String[] args) {
        //1、创建服务--创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //2、执行
        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());
    }
}

运行结果如下：
在这里插入图片描述