多线程笔记

1、线程简介

核心概念

1、线程就是独立的执行路径。

2、在程序运行时，即使没有自己创建程序，后台也会有多个线程，如主线程、gc线程。

3、main()称之为主线程，为系统的入口，用于执行整个程序。

4、在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统密切相关的，先后顺序是不能人为的干预的。

5、对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。

6、线程会带来额外的开销，如：CPU调度时间、并发控制开销

7、每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

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

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

2、线程实现（重点）

三种创建方式：

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

自定义线程类继承Thread类

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

创建线程对象，调用start()方法启动线程

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

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、线程同步（重点）

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

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

线程同步：

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁,独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：
1、一个线程持有锁会导致其他所有需要此锁的线程挂起；
2、在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时,引起性能问题；
3、如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。

同步方法：

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。
同步方法: public synchronized void method(int args){ }
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
缺陷：若将一个大的方法申明为synchronized 将会影响效率。

同步方法弊端：

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

同步块：

同步块：synchronized (Obj ){ }
Obj称之为同步监视器：
1、Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
2、同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this ，就是这个对象本身，或者是class[反射中讲解]
同步监视器的执行过程：
1、第一个线程访问，锁定同步监视器，执行其中代码；
2、第二个线程访问，发现同步监视器被锁定，无法访问；
3、第一个线程访问完毕，解锁同步监视器；
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());
    }
}

运行结果如下：

死锁：

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

死锁避免方法：

产生死锁的四个必要条件：
1、互斥条件：一个资源一次只能被一个进程使用；
2、请求与保持条件：一个进程因请求资源被阻塞时，对已获得的资源保持不放；
3、不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺；
4、循环等待条件：若干进程之间形成一种头尾相连的循环等待资源关系。
上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生。

代码演示死锁：

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(锁)

1、从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当；
2、java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象；
3、ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

代码演示如下：

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的对比

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

5、线程通信问题

生产者消费者模式

应用场景：生产者和消费者问题
1、假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费。
2、如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止。
3、如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

线程通信-分析

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。
1、对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者消费。
2、对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费。
3、在生产者消费者问题中，仅有synchronized是不够的
（1）synchronized可阻止并发更新同一个共享资源，实现了同步。
（2）synchronized不能用来实现不同线程之间的消息传递(通信)

解决方式：

解决方式1：
并发协作模型“生产者/消费者模式”—>管程法
生产者：负责生产数据的模块(可能是方法，对象，线程，进程)；
消费者：负责处理数据的模块(可能是方法，对象，线程，进程)；
缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

解决方式2：
并发协作模型“生产者/消费者模式”—>信号灯法

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

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

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

6、高级主题

线程池：

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：
提高响应速度（减少了创建新线程的时间) 降低资源消耗（(重复利用线程池中线程，不需要每次都创建) 便于线程管理(…)
corePoolSize：核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止

JDK 5.0起提供了线程池相关API: ExecutorService和Executors
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
1、void execute(Runnable command)︰执行任务/命令，没有返回值，一般用来执行Runnable
2、< T >Future< T > submit(Callable< T > task)：执行任务，有返回值，一般又来执行Callable
3、void shutdown()：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

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());
    }
}

运行结果如下：