多线程知识总结

多线程

1、线程简介

1、关键字：任务、进程、进程、多线程

2、普通方法调用和多线程

3、核心概念

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

2、线程实现（重点）

1、继承Thread类（重点）

实现过程：

1. 自定义线程类继承Thread类
2. 重写run()方法，编写线程执行体
3. 创建线程对象，调用start()方法启动线程

测试代码：

package per.mobian.thread;

//实现Thread接口
public class TestThread01 extends Thread {
    //实现接口后，重写里面的run()方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("执行测试线程" + i);
        }
    }
    public static void main(String[] args) {

        //开启多线程，实例化类，并且调用它的start()方法
        TestThread01 testThread01 = new TestThread01();
        testThread01.start();
        
        for (int i = 0; i < 5; i++) {
            System.out.println("执行了主线程" + i);
        }
    }
}

执行结果：

执行了主线程0
执行了主线程1
执行了主线程2
执行测试线程0
执行测试线程1
执行测试线程2
执行了主线程3
执行测试线程3
执行了主线程4
执行测试线程4

测试小案例：

编写一个多线程的下载程序，用于实现在网络上下载图片

package per.mobian.thread;

import org.apache.commons.io.FileUtils;

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

//4.继承Thread方法
public class TestThread2 extends Thread {
    private String url;
    private String name;

    //构造方法
    public TestThread2(String url, String name) {
        this.url = url;
        this.name = name;
    }

    public TestThread2() {
    }

    //5.重写run()方法
    @Override
    public void run() {
        //6.实例化下载器类，并且调用下载器类的下载文件的方法
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downLoader(url, name);
        System.out.println("下载了文件" + name);
    }

    public static void main(String[] args) {
        //7.实例化线程类，再开启这个类的多线程
        TestThread2 t1 = new TestThread2("http://pic1.win4000.com/wallpaper/2017-11-17/5a0e94afc140c.jpg", "1.jpg");
        TestThread2 t2 = new TestThread2("http://ppic.meituba.com/uploads/allimg/2016/10/11/158_888.jpg", "2.jpg");
        TestThread2 t3 = new TestThread2("http://img.juimg.com/tuku/yulantu/110715/9128-110G514440969.jpg", "3.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}

//1.编写一个下载器
class WebDownloader {
    //2.编写一个下载器类的下载方法
    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异常");
        }
    }
}

测试结果：

下载了文件2.jpg
下载了文件3.jpg
下载了文件1.jpg

注意：

1. 编写下载器类的时候，需要导入commons-io-2.6.jar （版本自选）
2. 用IDEA复制jar包到lib目录下后，需要点击Add as library添加到 library中
3. 图片的网络地址，需要自选

2、实现Runnable接口（重点）

实现过程：

1. 定义MyRunnable类实现Runnable接口
2. 实现run()方法，编写线程执行体
3. 创建线程对象，调用start()方法启动线程

测试代码：

package per.mobian.thread;

//实现了Runnable接口
public class TestRunndble01 implements Runnable {
    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("执行了多线程方法" + i);
        }
    }

    public static void main(String[] args) {
        //实例化多线程类
        TestRunndble01 testRunndble01 = new TestRunndble01();
        //使用实现接口的方式，开启多线程（Thread的源码也就是实现Runnable接口），此处的实现方式与静态代理的设计模式有关
        new Thread(testRunndble01).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("执行了主线程的方法" + i);
        }
    }
}

执行结果：

执行了主线程的方法0
执行了多线程方法0
执行了主线程的方法1
执行了多线程方法1
执行了多线程方法2
执行了多线程方法3
执行了主线程的方法2
执行了多线程方法4
执行了主线程的方法3
执行了主线程的方法4

对应于之前的小测试的修改：

//实现方式变成实现接口
public class TestRunnable02 implements Runnable

//使用此方法进行调用多线程
new Thread(t1).start();
new Thread(t2).start();
new Thread(t3).start();

3、两种方式的比较

• 继承Thread类
  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用：避免OOP单继承局限性
• 实现Runnable接口
  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start()
  • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

4、龟兔赛跑小案例

测试代码：

package per.mobian.thread;

public class TestRunnable04 implements Runnable {
    //胜利者
    private static String winner;
    
    //模拟龟兔赛跑的步数
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子")) {
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag == true) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "米");
        }
    }
    //判断是否完成比赛
    public boolean gameOver(int steps) {
        //在第一个到达20米的时候，winner被赋值
        if (winner != null) {
            return true;
        } else {
            if (steps >= 20) {
                winner = Thread.currentThread().getName();
                System.out.println(winner + "是胜利者");
                return true;
            } else {
                return false;
            }
        }
    }

    //main()方法开启多线程
    public static void main(String[] args) {
        TestRunnable04 t1 = new TestRunnable04();
        new Thread(t1, "兔子").start();
        new Thread(t1, "乌龟").start();
    }
}

执行而结果：

//此结果中，兔子只跑了1米
乌龟跑了1米
乌龟跑了2米
乌龟跑了3米
乌龟跑了4米
乌龟跑了5米
乌龟跑了6米
乌龟跑了7米
兔子跑了1米
乌龟跑了8米
乌龟跑了9米
乌龟跑了10米
乌龟跑了11米
乌龟跑了12米
乌龟跑了13米
乌龟跑了14米
乌龟跑了15米
乌龟跑了16米
乌龟跑了17米
乌龟跑了18米
乌龟跑了19米
乌龟是胜利者

4、实现Callable接口（了解）

实现过程：

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

测试代码：

package per.mobian.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 TestCallable implements Callable<Boolean> {
    private String url;
    private String name;

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

    public TestCallable() {
    }

    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downLoader(url, name);
        System.out.println("下载了文件" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("http://pic1.win4000.com/wallpaper/2017-11-17/5a0e94afc140c.jpg", "1.jpg");
        TestCallable t2 = new TestCallable("http://ppic.meituba.com/uploads/allimg/2016/10/11/158_888.jpg", "2.jpg");
        TestCallable t3 = new TestCallable("http://img.juimg.com/tuku/yulantu/110715/9128-110G514440969.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();
        //打印执行成功后的布尔值
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        //关闭服务
        ser.shutdownNow();
    }
}

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异常");
        }
    }
}

执行结果：

下载了文件3.jpg
下载了文件2.jpg
下载了文件1.jpg
true
true
true

5、静态代理模式（多线程底层实现）

测试代码：

package per.mobian.thread;

//定义接口，对比多线程的Runnable接口
interface Marry {
    void happyMarry();
}
//定义测试类
public class TestStaticProxy {
    public static void main(String[] args) {
        //正常的实现多线程的方法
//        WeddingCompany weddingCompany = new WeddingCompany(new You());
//        weddingCompany.happyMarry();

        //使用化简以后的，实现多线程的方法
         new WeddingCompany(new You()).happyMarry();

        //使用使用匿名内部类（直接new接口，重写接口方法），实现多线程的方法
        new Thread(new Runnable() {
            @Override
            public void run() {
            }
        }).start();
    }
}

//定义真实角色，对标实现Runnable类的具体执行类
class You implements Marry {
    @Override
    public void happyMarry() {
        System.out.println("默辨结婚了");
    }
}

//定义代理角色婚庆公式，对标Thread类
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("这是结婚之后");
    }
}

执行结果：

这是结婚之前
默辨结婚了
这是结婚之后

总结：

多线程的实现方式就是利用了静态代理模式。我们转到源码

//Runnable接口
public interface Runnable {
    public abstract void run();
}
//正常的带参的Thread方法的源码，次类为静态代理类，代理我们自己编写的多线程方法
public Thread(Runnable target) {
    this(null, target, "Thread-" + nextThreadNum(), 0);
}

//自己定义的多线程类分为两种，由于Thread类底层也是实现了Runnable接口的，所以我将两者都归类为实现接口的方式
class Thread implements Runnable {
    //调用此方法就类似于调用结婚这个方法
    public synchronized void start() {
        if (threadStatus != 0){
            throw new IllegalThreadStateException();
        }
        group.add(this);
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
}

3、Lambda表达式

λ java8特性

• λ希腊希姆表中排序第是一位的字母，英文名称为Lamda
• 避免匿名内部类定义过多
• 其实质属于函数式编程概念

1、函数式接口的定义

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

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

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

测试代码：Lambda的演变（五种定义类的方式：外部类、静态内部类、局部内部类、匿名内部类、Lambda表达式）

package per.mobian.thread;

//定义一个函数式接口
interface ILike {
    void Lambda();
}
//定义一个接口的实现类(正常的实现方法)
class Like implements ILike {
    @Override
    public void Lambda() {
        System.out.println("执行了Lambda表达式1");
    }
}

public class TestLambda {
    //2、使用静态内部类的方式实现
    static class Like2 implements ILike {
        @Override
        public void Lambda() {
            System.out.println("执行了Lambda表达式2");
        }
    }
    
    public static void main(String[] args) {
        //3、使用局部内部类的方式
        class Like3 implements ILike {
            @Override
            public void Lambda() {
                System.out.println("执行了Lambda表达式3");
            }
        }
        //1、正常的实现方法
        ILike like = new Like();
        like.Lambda();

        //2、使用静态内部类的方式实现
        like = new Like2();
        like.Lambda();

        //3、使用局部内部类的方法
        like = new Like3();
        like.Lambda();

        //4、使用匿名内部类,类没有名字，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void Lambda() {
                System.out.println("执行了Lambda表达式4");
            }
        };
        like.Lambda();

        //5、使用Lambda表达式(直接复制接口方法后面的所有代码再加上->即可)
        like = () ->{
            System.out.println("执行了Lambda表达式5");
        };
        like.Lambda();
    }
}

执行结果：

执行了Lambda表达式1
执行了Lambda表达式2
执行了Lambda表达式3
执行了Lambda表达式4
执行了Lambda表达式5

带参数的测试代码：

package per.mobian.thread;

interface ILove {
    void love(int a);
}

public class TestLambda2 {
    public static void main(String[] args) {
        ILove iLove = null;

        //1.lambda表示简化
        iLove = (int a) -> {
            System.out.println("a是：" + a);
        };
        iLove.love(1);

        //简化1、参数类型
        iLove = (a) -> {
            System.out.println("a是：" + a);
        };
        iLove.love(2);
        //简化2、简化括号
        iLove = a -> {
            System.out.println("a是：" + a);
        };
        iLove.love(3);

        //简化3、去掉花括号
        iLove = a -> System.out.println("a是：" + a);
        iLove.love(4);
    }
}

测试结果：

a是：1
a是：2
a是：3
a是：4

总结：

1. 化简2与化简3的前提是，参数和方法体只有一条语句，超出范围则无法使用
2. 使用函数式简化的前提为，接口为函数式接口
3. 正常情况使用化简1的样式即可

3、线程状态

1、线程的五种状态的切换

2、停止线程

注意事项：

• 不推荐使用JDK提供的stop()、destory()方法
• 推荐线程自己停止下来
• 建议使用一个标志位进行终止变量，当flag=false，则终止线程运行

测试代码：

package pers.mobian.thread;

public class TestStopThread implements Runnable {
    private boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            System.out.println("我是多线程程序，我还在运行:" );
        }
    }

    //手写外部程序用于中断多线程程序的执行
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStopThread testStopThread = new TestStopThread();
        new Thread(testStopThread).start();
        for (int i = 1; i < 5; i++) {
            System.out.println("主方法执行次数：" + i);
            //中断程序执行的外部条件
            if (i == 2) {
                testStopThread.stop();
            }
        }
    }
}

测试结果：

我是多线程程序，我还在运行:
我是多线程程序，我还在运行:
我是多线程程序，我还在运行:
主方法执行次数：1
主方法执行次数：2
我是多线程程序，我还在运行:
主方法执行次数：3
主方法执行次数：4

3、线程休眠

注意事项：

• sleep(时间) 指定当前线程阻塞的毫秒数
• sleep存在异常InterruptedException
• sleep时间达到后线程进入就绪状态
• sleep可以模拟网络延时，倒计时等
• 每一个对象都有一个锁，sleep不会是方法锁

利用线程休眠，制作一个打印当前时间的案例：

package pers.mobian.thread;

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleepThread {
    public static void main(String[] args) throws InterruptedException {

        //打印当前时间
        Date startTime = new Date(System.currentTimeMillis());
        while(true) {
            Thread.sleep(1000);
            //根据指定格式，打印时间
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
            //重新赋值时间，跟新时间
            startTime = new Date(System.currentTimeMillis());
        }
    }
}

执行结果：

16:40:49
16:40:50
16:40:51
16:40:52

4、线程礼让

注意事项：

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

测试代码：

package pers.mobian.thread;

public class TestYieldThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程执行开始");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程执行结束");
    }
    
    public static void main(String[] args) {
        TestYieldThread t1 = new TestYieldThread();
        new Thread(t1,"a线程：").start();
        new Thread(t1,"b线程：").start();
    }
}

执行结果：

//此结果为礼让成功
a线程：线程执行开始
b线程：线程执行开始
a线程：线程执行结束
b线程：线程执行结束

5、Join 强制执行

注意事项：

• Join合并线程，待此线程执行完成后，再执行其他的线程，其他线程阻塞
• 可以想象成插队

测试代码：

package pers.mobian.thread;

public class TestJoinThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("我是多线程任务，我是插队的VIP");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoinThread testJoinThread = new TestJoinThread();
        new Thread(testJoinThread).start();

        for (int i = 0; i < 1000; i++) {
            if(i == 100) {
                new Thread(testJoinThread).join();
            }
            System.out.println("主方法执行次数："+i);
        }

    }
}

执行结果：

//如果执行是先主方法，则当i=100的时候，执行多线程任务，直到多线程任务执行结束，才返回之前执行的主方法

6、观测线程状态

package pers.mobian.thread;

public class TestStateThread {
    public static void main(String[] args) throws InterruptedException {

        //使用lambda表达式，新建一个多线程任务
        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);
        System.out.println("===");

        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);//Run
        System.out.println("===1");

        //当线程状态是停止（terminated）的时候，跳出循环
        while (state != Thread.State.TERMINATED) {
            Thread.sleep(1000);
            state = thread.getState();
            System.out.println(state);
        }

        thread.start();//线程死亡后，无法再次开启
    }
}

执行结果：

NEW
===
RUNNABLE
===1
TIMED_WAITING
TIMED_WAITING
RUNNABLE
TIMED_WAITING
RUNNABLE
\\\
    //最后异常是因为线程死亡后的再次启动报错
Exception in thread "main" java.lang.IllegalThreadStateException
TERMINATED
at java.base/java.lang.Thread.start(Thread.java:794)
at pers.mobian.thread.TestStateThread.main(TestStateThread.java:34)

总结：

7、线程的优先级

测试代码：

package pers.mobian.thread;

public class TestPriorityThread implements Runnable {
    public static void main(String[] args) {
        TestPriorityThread testPriorityThread = new TestPriorityThread();
        Thread t1 = new Thread(testPriorityThread);
        Thread t2 = new Thread(testPriorityThread);
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority());
        t1.start();

        //设置优先级,当设置的范围不再1-10，则会抛出异常
        t2.setPriority(8);
        t2.start();
    }

    @Override
    public void run() {
        //打印线程名字和线程优先级
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority());
    }
}

main:5
Thread-0:5
Thread-1:8

8、守护(daemon)线程

注意事项：

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

测试代码：

package pers.mobian.thread;

public class TestDaemonThread {
    public static void main(String[] args) {
        God god = new God();
        Thread thread = new Thread(god);

        //将God线程设置成守护线程，setDaemon的参数默认是false
        //守护线程按道理不会结束，但是用户线程结束以后，守护线程也会跟着结束，两者之间相差一个虚拟机的相应时间
        thread.setDaemon(true);
        thread.start();

        new Thread(new 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 < 20; i++) {
            System.out.println("这是一个用户线程");
        }
    }
}

执行结果：

这是一个守护线程
这是一个守护线程
这是一个用户线程
//共20个
这是一个用户线程
这是一个守护线程
//虚拟机停止的时间段打印的语句：这是一个守护线程
这是一个守护线程

4、线程同步（重点）

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

线程同不的安全性需要：队列+锁

1、synchronized(Obj){}

线程不安全的测试代码一：

//该测试证明了，Array是线程不安全的
package pers.mobian.thread;

import java.util.ArrayList;
import java.util.List;

public class TestUnsafeThread {
    public static void main(String[] args) {
        List<String> arr = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
               arr.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(arr);
        //打印添加以后的集合的长度
        System.out.println(arr.size());
    }
}

执行结果：

[Thread-0, Thread-2, Thread-6, Thread-5, Thread-4, Thread-3, Thread-7, Thread-1, Thread-13, Thread-14, Thread-12, Thread-15]
15

线程不安全的测试案例二：

package pers.mobian.thread;

//买票的不安全性
public class TestUnsafeThread2 {
    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 tickets = 10;
    boolean flag = true;

    @Override
    public  void run() {
        while(flag) {
            //买票的方法体
            buy();
        }
    }
    //买票的方法
    private  void buy() {
        if(tickets <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+"买了第"+tickets--+"票");
    }
}

执行结果：

我买了第10票
我买了第7票
我买了第6票
我买了第5票
你买了第9票
他买了第8票
你买了第3票
我买了第4票
你买了第1票
他买了第2票
你买了第0票
我买了第-1票

总结：上述两个例子，都证明了线程在运行过程中的没有同不执行的问题，即所谓的线程不安全

案例一优化代码：

package pers.mobian.thread;

import java.util.ArrayList;
import java.util.List;

public class TestUnsafeThread {
    public static void main(String[] args) throws InterruptedException {
        List<String> arr = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                //有synchronized关键字包裹整个代码块
                synchronized (arr){
                    arr.add(Thread.currentThread().getName());
                }
            }).start();
        }
        //需要添加睡眠一秒钟，继而达到数据更加的明确
        Thread.sleep(1000);
        System.out.println(arr.size());       
    }
}

案例二优化代码：

private synchronized void buy()

总结：

补充：

CopyOnWriteArrayList集合是线程安全的，是一个底层是有锁的集合

package pers.mobian.thread;

import java.util.concurrent.CopyOnWriteArrayList;

public class TestGUCThread {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> arr = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                arr.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(arr.size());
    }
}

死锁：

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

产生死锁的四个必要条件：

1. 互斥条件：一个资源每次只能被一个进程使用。
2. 请求与保持条件：与i个进程因请求资源而阻塞时，对已获得的资源保持不放
3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
4. 循环等待条件：若干进程之间形成一种头尾想接的循环等待资源关系

总结：上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

测试代码：

package pers.mobian.thread;


//口红类
class Lipstick {

}

//镜子类
class Mirror {

}

//化妆类
class Makeup implements Runnable {

    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    //选择先得到口红还是镜子的判定
    int choice;
    String name;

    public 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(name + "获得了口红");
                Thread.sleep(1000);
                synchronized (mirror) {
                    System.out.println(name + "获得了镜子");
                }
            }
        } else {
            synchronized (mirror) {
                System.out.println(name + "获得了镜子");
                Thread.sleep(2000);
                synchronized (lipstick) {
                    System.out.println(name + "获得了口红");
                }
            }

        }
    }
}

public class TestLockThread {
    public static void main(String[] args) {
        Makeup m1 = new Makeup(1, "pan");
        new Thread(m1).start();
        Makeup m2 = new Makeup(0, "mobian");
        new Thread(m2).start();
    }
}

执行结果：

//由于他们都获取不到下一步的锁，多以出现了死锁的现象
pan获得了镜子
mobian获得了口红
    
//解决方式：第二次获得锁的代码块外提
    
//如：
else {
    synchronized (mirror) {
        System.out.println(name + "获得了镜子");
        Thread.sleep(2000);
    }
    synchronized (lipstick) {
            System.out.println(name + "获得了口红");
        }
}

2、Lock(锁)

测试代码：

package pers.mobian.thread;

import java.util.concurrent.locks.ReentrantLock;

public class TestLockThread2 {
    public static void main(String[] args) {
        BuyTickets b1 = new BuyTickets();

        new Thread(b1).start();
        new Thread(b1).start();
        new Thread(b1).start();
    }
}

//买票的案例
class BuyTickets implements Runnable {
    private int nums = 10;
    //定义的方式，模仿源码的写法
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //使用lock锁时，使用try{}finally{}语句，对相应的代码块进行相应的操作
            try {
                lock.lock();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (nums <= 0) {
                    break;
                } else {
                    System.out.println(nums--);
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

执行结果：

//10-1的依次打印
10
9
8
7
6
5
4
3
2
1

补充：synchronized与Lock的对比

5、线程通信问题

线程通信，问题分析：

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

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

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

解决方式一：

测试代码：

package pers.mobian.thread;

import java.util.zip.CheckedInputStream;

//管程法
public class TestPCThread {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Customer(container).start();
    }
}

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

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

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

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

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

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("消费了第" + container.pop().id + "只鸡");
        }
    }
}

//商品
class Chicken {
    int id;
    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区的
class SynContainer {
    //需要一个容器存放物品
    Chicken[] chickens = new Chicken[3];
    int count = 1;

    //生产者放入产品
    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;
    }
}

执行结果：

//达到了预期效果
生产了1只鸡
消费了第1只鸡
生产了2只鸡
消费了第2只鸡
生产了3只鸡
消费了第3只鸡
生产了4只鸡
消费了第4只鸡
生产了5只鸡
消费了第5只鸡
生产了6只鸡
消费了第6只鸡
生产了7只鸡
生产了8只鸡
生产了9只鸡
消费了第7只鸡
消费了第9只鸡
生产了10只鸡
消费了第10只鸡
消费了第8只鸡

解决方式二：

测试代码：

package pers.mobian.thread;

public class TestPCThread2 {
    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;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; 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;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; 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;
    }
}

执行结果：

演员表演了：节目一
观看了：节目一
演员表演了：节目二
观看了：节目二
演员表演了：节目一
观看了：节目一
演员表演了：节目二
观看了：节目二
演员表演了：节目一
观看了：节目一

线程池：

使用：

测试代码：

package pers.mobian.thread;

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

public class TestPoolThread {
    public static void main(String[] args) {
        //创建线程池,并且设置线程池的大小为2
        ExecutorService service = Executors.newFixedThreadPool(2);

        //Runnable接口的创建方式
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭线程
        service.shutdown();
    }
}

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

执行结果：

pool-1-thread-1
pool-1-thread-1
pool-1-thread-2