多线程---kuang

多线程

1：线程进程多线程初步了解

什么是进程：
进程就是正在运行的单位；
1：用户角度：进程是程序的一次动态执行过程；
2：操作系统：进程是操作系统分配资源的基本单位，也是最小单位；

什么是线程：
线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

什么是并发：
并发，在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行。

1.进程(Process):就是把一个程序跑起来。
⒉线程(Thread)“*很多线程都是模拟出来的。真正的多线程是指含有多个CPU，即多核，如服务器。而模拟出来的多线程，则是在一个CPU，在同一个时间点，CPU只能执行一次代码，因为切换的很快，所以就会造成同时执行的错觉。

通常一个进程可以包含多个线程，当然至少包含一个，不然该进程就没有任何存在的意义。
进程是系统资源分配的单位，线程是CPU调度和执行的单位。

线程就是独立的执行路径。
程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程（垃圾回收线程）。
main()是主线程，是系统的入口，用于执行整个程序。
在同一个进程里面，线程也不能是哪个想进就可以进来的，他是需要调度器CPU的安排调度，CPU与操作系统紧密相连，先后顺序是不能被干预的。
对同一份资源是需要进行并发控制的，以免进行资源抢夺。
线程会带来额外的开销，如CPU的调度时间、并发控制开销。
每个线程在自己的工作内存交互，内存控制不当就会造成数据不一致。

2：创建线程（Thread、 Runnable、 Callable）

1：三种创建方式：

2：Thread（线程开始不一定马上执行，他是需要CPU去调度执行的。）

方式一：继承Thread类，重写run方法，调用start开启线程；

@Override
    //创建方式一：继承Thread类，重写run方法，调用Start开启线程；

    //结论：线程开启后不一定立即执行，是由CPU调度的；

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

        //调用start()方法  开启线程
        testThread1.start();

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

使用多线程，下载网图：


//使用多线程，下载网图
public class TestThread2  extends Thread{

    private String url;
    private String name;

    public TestThread2(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) {

        TestThread2 t1 = new TestThread2("https://t7.baidu.com/it/u=1951548898,3927145&fm=193&f=GIF","1.gif");
        TestThread2 t2 = new TestThread2("https://t7.baidu.com/it/u=4162611394,4275913936&fm=193&f=GIF","2.gif");
        TestThread2 t3 = new TestThread2("https://t7.baidu.com/it/u=2851687453,2321283050&fm=193&f=GIF","3.gif");

        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("图片下载异常！");
        }
    }

方式二：实现runnable接口，重写run方法。在运行多线程时需要输入一个runnable实现类，然后调用start方法，启动线程。


    //方法一（不建议使用）：避免OOP单线程局限性。  (TestThreaf1)
    //方法二（推荐使用）：避免单继承局限性，灵活方便，方便同一个对象被多个单线程使用。 (TestThreaf3)

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习---"+i);
        }
    }

    public static void main(String[] args) {

        //创建Runnable接口的实现类；
        TestThread3 testThread3 = new TestThread3();

        //创建线程对象，通过线程的对象来开启我们的线程；代理
        Thread thread = new Thread(testThread3);
        thread.start();

       // new Thread(testThread3).start();  总的一句话；



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

案例：多个线程使用同一个资源时，数据会发生紊乱，数据不安全；

为什么线程是不安全的：
多线程同时操作对象的属性或者状态时，会因为线程之间的信息不同步，A线程读取到的状态已经过时，而A线程并不知道。所以并发安全的本质问题在于线程之间的信息不同步！


//多个线程同时操作一个对象
//买火车票的案例
public class TestThread4  implements Runnable{

    //票数；
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNums<=0){
                break;
            }

            //模拟延迟
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"--->拿到了第"+ticketNums--+"票");

        }
    }

    public static void main(String[] args) {

        //创建一个Runnable接口的实现类
        TestThread4 ticket = new TestThread4();

        //创建一个线程，通过现成的对象来开启我们的线程，代理
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛党").start();
    }

实际案例：龟兔赛跑小游戏；

首先来个赛道距离，然后要离终点越来越近
判断比赛是否结束
打印出胜利者
龟兔赛跑开始
故事中是乌龟赢的，兔子需要睡觉，所以我们来模拟兔子睡觉。
终于，乌龟赢得比赛。

//胜利者
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(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //判断是否完成比赛；
        boolean flag = gameOver(i);
        //如果比赛结束，停止比赛；
        if(flag){
            break;
        }

        System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步");
    }

}

//判断是否完成比赛
public boolean gameOver(int steps){
    //判断是否有获胜者；
    if (winner!=null){
        //说明这里已经有了获胜者
        return true;
    }else {
        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();
}

方法三：实现Callable接口（目前了解即可）

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


public class CallAble  implements Callable {

    private String url;
    private String name;

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


    @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 InterruptedException, ExecutionException {
        CallAble t1 = new CallAble("https://t7.baidu.com/it/u=1951548898,3927145&fm=193&f=GIF","1.gif");
        CallAble t2 = new CallAble("https://t7.baidu.com/it/u=4162611394,4275913936&fm=193&f=GIF","2.gif");
        CallAble t3 = new CallAble("https://t7.baidu.com/it/u=2851687453,2321283050&fm=193&f=GIF","3.gif");

        //创建执行服务；
        ExecutorService ser = Executors.newCachedThreadPool(3);

        //提交执行；
        Future submit1 = ser.submit(t1);
        Future submit2 = ser.submit(t2);
        Future submit3 = ser.submit(t3);

        //获取结果；
        boolean o1 = (boolean) submit1.get();
        boolean o2 = (boolean) submit1.get();
        boolean o3 = (boolean) submit1.get();

        //关闭服务；
        ser.shutdown();



    }


}


//下载器；
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("图片下载错误！");
        }
    }

3：静态代理模式

你：真实角色
婚庆公司：代理你，帮你处理结婚的事
都实现结婚借口即可
好处：代理对象可以做真实对象做不了的事情；真实对象只需要做好自己的事情就好。


//静态代理模式：
//真实的对象和代理的对象都要实现同一个接口；
//代理的对象要代理真正的角色；

//代理模式的好处：
    //代理对象可以做真实的对象做不了的事情；
    //真实的对象专注与做自己的事情；

public class StaticProxy {

    public static void main(String[] args) {
//        You you = new You();
//
        //这里比较下面两横代码，是非常相像的；是实现Runnable类的方式，new Thread(),start();
//        new Thread( ()-> System.out.println("我爱你！") ).start();
//        new WeddingCompany(you).HappyMarry();

        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}


interface Marry{
    void HappyMarry();
}

//真实的角色；
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("铁锤要结婚了。。。");
    }
}

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

    private Marry target;

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

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void after() {
        System.out.println("结婚之后，收份子钱！");
    }

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

4：Lambda表达式

避免匿名内部类太多
可以让你的代码看起很简洁
去掉没用的代码，只留下核心逻辑

1：函数式接口
只有一个抽象方法的接口，叫做函数式接口。

//1：定义一个函数式接口
interface ILink{
    void lambda();
}

2：我们可以通过Lamda表达式来创建该函数式接口的对象。

//2:实现类：
class link1 implements ILink{

    @Override
    public void lambda() {
        System.out.println("i  link  lambda1;");
    }
}

3：实现这个接口
//接口去new一个实现类；
ILink link = new link1();

link.lambda();
觉得很麻烦，就改装成为静态内部类，写在类里面的静态类，匿名内部类，到最后用Lambda表达式实现；
//4:局部内部类；
class link3 implements ILink{

    @Override
    public void lambda() {
        System.out.println("i  link  lambda3");
    }
}

link3 link3 = new link3();
link3.lambda();


//5:匿名内部类，没有类的名称，必须要借助接口或者是父类；
link = new ILink() {
    @Override
    public void lambda() {
        System.out.println("i  link  lambda4");
    }
};
link.lambda();

//6:简化：用lambda表达式；
link = ()-> {
    System.out.println("i  link  lambda5");
};
link.lambda();

小结：

/*
总结：
1：Lambda表达式前提必须是函数时接口，什么是函数是接口：（接口里面只允许有一个方法。）
2：Lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那就用代码块包裹，
3：多个参数也可以 去掉参数类型，要去掉都去掉，必须加上括号，

 */

5：线程状态

1：停止线程

不推荐使用JDK提供的stop()，destory()方法，这些已经被舍弃，不建议使用，。
推荐线程自己停下来；
建议使用一个标志位，终止变量，当flag = false时；则终止线程运行；

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("线程停止了:!");
            }
        }

    }

2：线程休眠(sleep)

Sleep(时间)指当前线程阻塞的毫秒数；
Sleep 存在异常
Sleep时间到达后，线程进入就绪状态
Sleep可以模拟网络延迟，倒计时等；
每一对象都有一把锁，sleep不会释放锁；


//多个线程同时操作一个对象
//模拟火车票
public class TestSleep implements Runnable{

    //创建一个票
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true){
            if (ticketNums <= 0){
                break;
            }

            //线程休眠；
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票");
        }

    }

    public static void main(String[] args) {

        TestSleep testSleep = new TestSleep();

        new Thread(testSleep,"小明：").start();
        new Thread(testSleep,"张三：").start();
        new Thread(testSleep,"黄牛党：").start();


    }

模拟倒计时：

//模拟倒计时
public static void tenDown() throws InterruptedException {
    int num = 10;
    while (true){
        Thread.sleep(1000);
        System.out.println(num--);
        if (num<=0){
            break;
        }

    }
}

打印当前系统时间：


public static void main(String[] args) throws InterruptedException {
   //tenDown();

    //打印当前的系统时间；
    //获取当前系统的时间；
    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());

    }

}

3：线程礼让(yield)

礼让线程，让当前正在执行的线程暂停，但不阻塞；
让线程从运行状态转为就绪状态；
让Cpu重新调度，礼让不一定成功，还是看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(Thread.currentThread().getName()+"线程开始执行！");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行！");
    }
}

4：线程强制执行(join)

Join合并线程，待此线程执行完毕后，在执行其他线程，其他线程阻塞；
可以想象成插队；

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


    TestJoin testJoin = new TestJoin();
    Thread thread = new Thread(testJoin);
    thread.start();

    //主线程
    for (int i = 0; i < 100; i++) {
        if (i == 50){
            thread.join();
        }
        System.out.println("main..:"+i);
    }



}

@Override
public void run() {
    for (int i = 0; i < 500; i++) {
        System.out.println("我是VIP线程-->"+ i);
    }

}

5：观察测试线程的状态

JDK文档：Thread.State;
public static enum Thread.State
extends Enum<Thread.State>
线程状态。线程可以处于以下状态之一：

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

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

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); //输出状态
    }
}

6: 线程的优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围从1~10.
Thread.MIlN_PRIORITY =1;
Thread.MAX_PRIORITY = 10;Thread.NORM_PRIORITY = 5;

使用以下方式改变或获取优先级
getPriority() . setPriority(int xxx)


    public static void main(String[] args) {

        //主线程默认优先级；
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread thread1 = new Thread(myPriority);
        Thread thread2 = new Thread(myPriority);
        Thread thread3 = new Thread(myPriority);
        Thread thread4 = new Thread(myPriority);
        Thread thread5 = new Thread(myPriority);

        thread1.start();

        thread2.setPriority(1);
        thread2.start();

        thread3.setPriority(4);
        thread3.start();

        thread4.setPriority(Thread.MAX_PRIORITY);
        thread4.start();


        thread5.setPriority(Thread.MIN_PRIORITY);
        thread5.start();

    }
}


class MyPriority implements Runnable{

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

7：守护线程（daemon）

线程分为用户线程和守护线程；
虚拟机必须确保用户线程执行完毕
虚拟机不要等待守护线程执行完毕
如：后台纪律操作日志，监测内存，垃圾回收等；

//测试守护线程；
//上帝守护着你；
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 You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 365; i++) {
            System.out.println("每天开心，拒绝EMO!!!");
        }
        System.out.println("====Good,,Bye!!!====");
    }
}

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

8：线程同步；

1：线程同步；
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题﹐为了保证数据在方法中被访问时的正确性﹐在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源﹐其他线程必须等待，

使用后释放锁即可.存在以下问题:

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

2：同步方法

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

缺陷:若将一个大的方法申明为synchronized 将会影响效率
（只读，修改）
弊端：方法里面需要修改的地方才需要锁，锁的太多，浪费资源；

3：同步块:

synchronized(Obj ){ } Obj称之为同步监视器
Obj可以是任何对象﹐但是推荐使用共享资源作为同步监视器
-同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this ,就是这个对象本身，或者是class [反射中讲解]

同步监视器的执行过程

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

8.1不安全的案例

买票案例###银行取钱案例###List案例

买票案例：

在这里要想买票安全 ，就在创建一个同步方法。
只需要在方法上加synchronized 就可以了

 //定义一个买票的方法
    private synchronized void buy() throws InterruptedException {
        if (ticketNums <= 0){
            flag = false;
            return;
        }







//买票
//不安全，买票
public class UnSafeBuyTicket {

    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"小明").start();
        new Thread(station,"小华").start();
        new Thread(station,"黄牛党").start();
    }
}

class BuyTicket implements Runnable{

    //票数；
    private int ticketNums = 10;
    boolean flag = true;


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

    //定义一个买票的方法
    private void buy() throws InterruptedException {
        if (ticketNums <= 0){
            flag = false;
            return;
        }

        //模拟延迟
        Thread.sleep(100);

        System.out.println(Thread.currentThread().getName()+"买到了第"+ticketNums--+"票");
    }

银行取钱案例：

这里创建了一个同步块


/模拟银行取钱
public class UnSafeBanker {

    public static void main(String[] args) {

        Account account = new Account(100,"结婚基金");

        Drawing you = new Drawing(account,50,"你");
        Drawing youFriend = new Drawing(account,100,"youFriend");

        you.start();
        youFriend.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;
    }


    //取钱；
    //synchronized默认所得是this
    @Override
    public  void run() {

        //所得对象就是变化的量，需要增删改的对象
        synchronized (account){
            if (account.money-drawingMoney<0){
                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);
        }


    }

List案例

这里也是创建了一个同步块


  public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }

            }).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());
    }

9：死锁

1：死锁

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

   public static void main(String[] args) {
        MakeUp makeUp1 = new MakeUp(0,"铁锤");
        MakeUp makeUp2 = new MakeUp(1,"幺鸡");

        makeUp1.start();
        makeUp2.start();

    }
}

//口红；
class MouseRed{

}

//镜子；
class Mirror{

}

//化妆；
class MakeUp extends Thread{

    //需要的资源只有一份，用Static来表示资源只有一份；
    static Mirror mirror = new Mirror();
    static MouseRed mouseRed = new MouseRed();

    int choice;//选择
    String girlName;//使用化妆品的人；

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


    @Override
    public void run() {
        try {
            makeUp();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆，互相持有对方的锁，就是需要拿到对方的资源；
    private void makeUp() throws InterruptedException {

        if (choice == 0){
            synchronized (mouseRed){
                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(3000);//一秒钟之后想获得镜子的锁
//                synchronized (mouseRed){
//                    System.out.println(this.girlName+"获得口红的锁");
//                }

            }
            synchronized (mouseRed){
                System.out.println(this.girlName+"获得口红的锁");
            }
        }

利用一个信号灯法，创建一个标志位

//测试生产者消费者，问题2：信号灯法，通过一个标志位
public class TestPC2 {

    public static void main(String[] args) {
        TV tv = new TV();

        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者--->演员
class Player extends Thread{
     TV tv = new TV();

     public Player(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 Watcher extends Thread{
    TV tv = new TV();

    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//产品--->节目
class TV{

    //演员表演，观众等待；T
    //观众观看，演员等待；F
    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.notify();
        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.notify();
        this.flag = !this.flag;


    }

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

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

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

3：Lock锁

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


public class Testlock2 {

    public static void main(String[] args) {

        Lock2 lock2 = new Lock2();

        new Thread(lock2).start();
        new Thread(lock2).start();
        new Thread(lock2).start();

    }
}

class Lock2 implements Runnable{
    int tickNums = 10;

    //定义一个Lock锁
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {

        while (true){

            try{
                lock.lock();
                if (tickNums>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(tickNums--);
                }else {
                    break;
                }

            }finally {
                lock.unlock();
            }


        }
    }