Thread多线程知识点 解决死锁问题

欢迎使# 线程（Thread）

Thread 线程s

• 多线程创建的方法
• 方式一：
• 1.自定义一个类继承Thread类
• 2.重写Thread的run方法，把自定义的线程的任务代码写在run方法中
• 3.创建Thread子类的对象调用start()方法开启线程
• 一个线程一旦开启那么就会执行run方法中的代码。
  *
  *
  多线程出现安全问题的根本原因：
  1.存在两个或两个以上的线程对象而且线程之间共享着一个资源
  2.有多个语句操作了共享资源

*问题一：50张票会出现被卖150次的情况
*解决方案：
*非静态的成员变量数据在每个对象中都会维护一份数据，三个线程就会有三分数据
* 所以num数据共享出来给三个线程使用使用static修饰

*问题二：出现了线程安全问题
解决方法：1.sun提供了线程同步机制让我们解决这类问题
java线程同步机制的方式：
方式一：同步代码块
synchronized(锁对象){
需要被同步的代码
}
同步代码块的注意事项：
1.任何一个对象都可以作为锁对象
就是凡是对象的内部都维护了一个状态，java同步机制使用了对象中的状态作为了锁的标识 stat=0开 1表示关
2.在同步代码块中调用sleep方法并不是是释放锁对象
3.只有真正存在线程安全问题时才使用同步代码块，否则会降低效率
4.多线程操作的锁必须是唯一的共享的。否则无效
方式二: 同步函数：使用synchronized修饰一个函数
同步函数要注意的事项：
1.如果是一个非静态同步函数的锁，对象是this(每个线程开启的对象是不一样的)所以达不到唯一的要求无效
如果是一个静态的同步函数，对象是当前函数所属类的字节码文件(class对象)
2.同步函数的的锁对象是固定的，不能由我们来决定
推荐使用同步代码块解决了线程的安全问题：
原因：1.同步代码块的锁对象是可以由我们随意指定，同步函数的锁对象是固定的，不能由我们指定
2.同步代码块方便控制需要同步代码的范围，而同步函数必须把整个函数的代码都被同步
*/

守护线程

package object.thread;
/*
* 守护线程也叫后台线程:在一个进程中如果只剩下了守护线程，那么守护线程也会死亡
* 一个线程默认都不为守护线程
* 当主线程结束时，是需要一定的时间来结束守护线程的，而不是瞬间就结束守护线程的。
* */

/*
* 模拟qq安装和更新
* */
//守护线程
class  Test extends  Thread{
    public Test(String name) {
        super(name);
    }
    @Override
    public void run() {

            for (int i = 0; i <=1000 ; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"安装包已经下载了"+i+"%");

        }

    }
}
public class Dome13 {
    public static void main(String[] args) {
        Test test=new Test("守护线程");
        test.setDaemon(true);
        /*setDaemon() 设置线程是否为守护线程，true为守护线程， false为非守护线程。
        System.out.println("是守护线程吗？"+ d.isDaemon()); //判断线程是否为守护线程。*/
        test.start();
        //下面的为主线程
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"下载了"+i+"%");

        }

    }

}

消费者和生产的线程问题

线程的通信

• 当一个线程完成了自己的任务的时候要通知另一个线程去完成另一个任务
• 生产者与消费者
• wait();等待
• notify();唤醒
• notifyAll()唤醒线程池中所有等待的线程
• wait与notify的方法要注意的事项
• 1.wait与notify方法属于Object对象的
• 2.wait与notify必须要在同步代码块或同步函数中实行
• 代码实现如下

• package object.thread;
  /*
   * 线程的通信
   * 当一个线程完成了自己的任务的时候要通知另一个线程去完成另一个任务
   *
   * 生产者与消费者
   * wait();等待
   * notify();唤醒
   * notifyAll()唤醒线程池中所有等待的线程
   * wait与notify的方法要注意的事项
   * 1.wait与notify方法属于Object对象的
   * 2.wait与notify必须要在同步代码块或同步函数中实行
   * 3.wait与notify方法必须由锁对象调用
   *
   * *
   * */
  
  
  //产品
  class Prodect {
      String name;//商品的名字
      double price;//商品的价格
      boolean flag;//商品默认没有生产
  
  
  }
  
  //生产者
  class Producer extends Thread {
      Prodect p;
  
      public Producer(Prodect p) {
          this.p = p;
      }
      @Override
      public void run() {
          int i = 0;
  
          while (true) {
  
                  //锁  对象为商品的对象
                  synchronized (p) {
                      if (!p.flag) {
                      if (i % 2 == 0) {
                          p.name = "苹果";
                          p.price = 6.5;
                          System.out.println("生产者生产出了" + p.name + "价格是" + p.price);
                      } else {
                          p.name = "香蕉";
                          p.price = 2.5;
                          System.out.println("生产者生产出了" + p.name + "价格是" + p.price);
                      }
                      i++;
                      p.flag = true;//生产之后flag=true 生产完毕
                          p.notify();//唤醒消费者去消费
                  }
  
                      else {
                          try {
                              p.wait();//等待消费者消费
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
  
                      }
              }
          }
      }
  }
  
  
  class Costmor extends Thread {
      Prodect p;
      public Costmor(Prodect p) {
          this.p = p;
      }
      @Override
      public void run() {
          while (true) {
              synchronized (p){
                  if (p.flag){//如果已经生产那么就消费
                      System.out.println("消费者消费了" + p.name + "价格为" + p.price);
                      p.flag=false;//消费完毕
                      p.notify();//唤醒生产者生产
                  }else {//如果没有生产那么久等待生产者的生产
                      try {
                          p.wait();//等待生产者生产产品
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
  
                  }
              }
  
  
          }
  
      }
  }
  
  public class Dome08 {
      public static void main(String[] args) {
          Prodect p = new Prodect();
          Producer producer = new Producer(p);
          Costmor costmorn = new Costmor(p);
          producer.start();
          costmorn.start();
  
  
      }
  
  }
  

线程的死锁的问题

案例一:

package object.thread.review;

/*
 * 死锁
 *一个人去找水源  一个去找水杯
 * 先拿到到水的去找水杯,如果此时cpu被拿水杯的那个线程抢占，此时双方就会进入一个循    环等待的过程，水杯和水在两个线程中此时就会出现死锁现象
 测试的时候适当增加线程的休眠时间来来检测
 *  */


//喝水的行为
class Drink {
    String water;//水
    String cup;//水杯
    boolean isdrink = false;//默认没有喝到水
    public Drink(String water, String cup) {
        this.water = water;
        this.cup = cup;
    }
}

//喝水的人1
class drinkPeople1 extends Thread {
    Drink drink;

    public drinkPeople1(Drink drink) {
        this.drink = drink;
    }

    @Override
    public void run() {
        boolean lock = true;
        while (lock) {
            try {
                sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (drink.cup) {
                System.out.println("站三找到了" + drink.cup + "正在找水");
                synchronized (drink.water) {
                    System.out.println("我找到了水" + drink.water);
                    System.out.println("我可以喝水了");
                    lock = false;//当喝到水的时候就释放资源
                }
            }
        }
    }
}
//合适的人2
class drinkPeople2 extends Thread {
    Drink drink;

    public drinkPeople2(Drink drink) {
        this.drink = drink;
    }

    @Override
    public void run() {
        boolean lock = true;
        while (lock) {
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (drink.water) {
                System.out.println("李四我找到了" + drink.water + "正在找水杯");

                synchronized (drink.cup) {
                    System.out.println("我可以喝水了");
                    lock = false;//喝到水之后释放资源
                }
            }
        }
    }
}

public class DeathLock {
    public static void main(String[] args) {
        Drink drink = new Drink("农府山泉", "水杯");
        //当两个线程共用同一个资源对象的时候，可能出现死锁的现象
        drinkPeople1 f1 = new drinkPeople1(drink);
        drinkPeople2 f2 = new drinkPeople2(drink);
        //两个线程都要执行一个功能，而共用同一个资源所以就会产生死锁的问题
        f1.start();
        f2.start();

    }


}

解决上述死锁的问题

package object.thread.review;

/*
 *解决死锁的问题
 *问题;一个人去找水源  一个去找水杯
 * 找到水的去找水杯   找到水杯的去找水  都想先喝水，最后渴死了
 *
 * 解决问题：分析
 * 要想线程之间能够协调就能解决死锁的问题这就用到了线程之间的通信
 * 线程的通信
 * 当一个线程完成了自己的任务的时候要通知另一个线程去完成另一个任务
 * 生产者与消费者
 * wait();等待
 * notify();唤醒
 * notifyAll()唤醒线程池中所有等待的线程
 * wait与notify的方法要注意的事项
 * 1.wait与notify方法属于Object对象的
 * 2.wait与notify必须要在同步代码块或同步函数中实行
 * 3.wait与notify方法必须由锁对象调用
 *
 *  */


//喝水的行为
class SolveDrink {
    String water;//水
    String cup;//水杯
    boolean isdrink = false;//默认没有喝到水

    public SolveDrink(String water, String cup) {
        this.water = water;
        this.cup = cup;
    }
}

//喝水的人1
class SolvedrinkPeople1 extends Thread {
    SolveDrink drink;

    public SolvedrinkPeople1(SolveDrink drink) {
        this.drink = drink;
    }

    @Override
    public void run() {
        boolean lock = true;
        while (true) {
            //如果水没有被喝那么张三开始去喝水
            synchronized (drink) {
                if (!drink.isdrink) {
                    try {
                        sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (drink.cup) {
                        System.out.println("张三找到了" + drink.cup + "正在找水");
                        synchronized (drink.water) {
                            System.out.println("我找到了水" + drink.water);
                            System.out.println("张三喝到水了");
                            drink.isdrink = true;//张三喝到水了
                            drink.notify();//唤醒另外的线程
                            lock = false;//当喝到水的时候就释放资源结束循环
                        }
                    }
                } else {//如果张三没有喝到水就等待
                    try {
                        drink.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        }
    }
}

//第二个喝水的人
class SolvedrinkPeople2 extends Thread {
    SolveDrink drink;

    public SolvedrinkPeople2(SolveDrink drink) {
        this.drink = drink;
    }

    @Override
    public void run() {

        boolean lock = true;
        while (true) {
            synchronized (drink) {
                if (drink.isdrink) {//如果isdrink为true说明张三已经喝到水了，第二个人开始喝水
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (drink.water) {
                        System.out.println("李四我找到了" + drink.water + "正在找水杯");
                        synchronized (drink.cup) {
                            System.out.println("李四找到了水杯");
                            System.out.println("李四我喝到水了");
                            drink.isdrink = false;//喝到水将isdrink置为false
                            drink.notify();//唤醒的等待的线程去喝水
                            lock = false;//喝到水之后释放资源结束循环
                        }
                    }
                } else {//上一个线程没执行完，资源没有释放，就要进入等待去等待资源
                    try {
                        drink.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }
}

public class SolveDeathLock {
    public static void main(String[] args) {
        SolveDrink solveDrink = new SolveDrink("农府山泉", "水杯");
        //当两个线程共用同一个资源对象的时候，可能出现死锁的现象
        SolvedrinkPeople1 f1 = new SolvedrinkPeople1(solveDrink);
        SolvedrinkPeople2 f2 = new SolvedrinkPeople2(solveDrink);
        f1.start();
        f2.start();

    }
}
```用Markdown编辑器

你好！ 这是你第一次使用 **Markdown编辑器** 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

## 新的改变

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：
 1. **全新的界面设计** ，将会带来全新的写作体验；
 2. 在创作中心设置你喜爱的代码高亮样式，Markdown **将代码片显示选择的高亮样式** 进行展示；
 3. 增加了 **图片拖拽** 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
 4. 全新的 **KaTeX数学公式** 语法；
 5. 增加了支持**甘特图的mermaid语法[^1]** 功能；
 6. 增加了 **多屏幕编辑** Markdown文章功能；
 7. 增加了 **焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置** 等功能，功能按钮位于编辑区域与预览区域中间；
 8. 增加了 **检查列表** 功能。
 [^1]: [mermaid语法说明](https://mermaidjs.github.io/)

## 功能快捷键

撤销：<kbd>Ctrl/Command</kbd> + <kbd>Z</kbd>
重做：<kbd>Ctrl/Command</kbd> + <kbd>Y</kbd>
加粗：<kbd>Ctrl/Command</kbd> + <kbd>B</kbd>
斜体：<kbd>Ctrl/Command</kbd> + <kbd>I</kbd>
标题：<kbd>Ctrl/Command</kbd> + <kbd>Shift</kbd> + <kbd>H</kbd>
无序列表：<kbd>Ctrl/Command</kbd> + <kbd>Shift</kbd> + <kbd>U</kbd>
有序列表：<kbd>Ctrl/Command</kbd> + <kbd>Shift</kbd> + <kbd>O</kbd>
检查列表：<kbd>Ctrl/Command</kbd> + <kbd>Shift</kbd> + <kbd>C</kbd>
插入代码：<kbd>Ctrl/Command</kbd> + <kbd>Shift</kbd> + <kbd>K</kbd>
插入链接：<kbd>Ctrl/Command</kbd> + <kbd>Shift</kbd> + <kbd>L</kbd>
插入图片：<kbd>Ctrl/Command</kbd> + <kbd>Shift</kbd> + <kbd>G</kbd>
查找：<kbd>Ctrl/Command</kbd> + <kbd>F</kbd>
替换：<kbd>Ctrl/Command</kbd> + <kbd>G</kbd>

## 合理的创建标题，有助于目录的生成

直接输入1次<kbd>#</kbd>，并按下<kbd>space</kbd>后，将生成1级标题。
输入2次<kbd>#</kbd>，并按下<kbd>space</kbd>后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用`TOC`语法后生成一个完美的目录。

## 如何改变文本的样式

*强调文本* _强调文本_

**加粗文本** __加粗文本__

==标记文本==

~~删除文本~~

> 引用文本

H~2~O is是液体。

2^10^ 运算结果是 1024.

## 插入链接与图片

链接: [link](https://www.csdn.net/).

图片: ![Alt](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9hdmF0YXIuY3Nkbi5uZXQvNy83L0IvMV9yYWxmX2h4MTYzY29tLmpwZw)

带尺寸的图片: ![Alt](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9hdmF0YXIuY3Nkbi5uZXQvNy83L0IvMV9yYWxmX2h4MTYzY29tLmpwZw =30x30)

居中的图片: ![Alt](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9hdmF0YXIuY3Nkbi5uZXQvNy83L0IvMV9yYWxmX2h4MTYzY29tLmpwZw#pic_center)

居中并且带尺寸的图片: ![Alt](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9hdmF0YXIuY3Nkbi5uZXQvNy83L0IvMV9yYWxmX2h4MTYzY29tLmpwZw#pic_center =30x30)

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

## 如何插入一段漂亮的代码片

去[博客设置](https://mp.csdn.net/console/configBlog)页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 `代码片`.
```javascript
// An highlighted block
var foo = 'bar';

生成一个适合你的列表

• 项目
  • 项目
    • 项目

1. 项目1
2. 项目2
3. 项目3

• 计划任务
• 完成任务

创建一个表格

一个简单的表格是这么创建的：

项目	Value
电脑	$1600
手机	$12
导管	$1

设定内容居中、居左、居右

使用:---------:居中
使用:----------居左
使用----------:居右

第一列	第二列	第三列
第一列文本居中	第二列文本居右	第三列文本居左

SmartyPants

SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：

TYPE	ASCII	HTML
Single backticks	'Isn't this fun?'	‘Isn’t this fun?’
Quotes	"Isn't this fun?"	“Isn’t this fun?”
Dashes	-- is en-dash, --- is em-dash	– is en-dash, — is em-dash

创建一个自定义列表

Markdown

Text-to- HTML conversion tool

Authors

John

Luke

如何创建一个注脚

一个具有注脚的文本。¹

注释也是必不可少的

Markdown将文本转换为 HTML。

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 $\Gamma (n)=(n-1)!\forall n\in \mathbb{N}$ 是通过欧拉积分

$$\Gamma (z)={\int }_0^{\infty }{t}^{z-1}{e}^{-t}dt.$$

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章

• 关于 甘特图 语法，参考 这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：

这将产生一个流程图。:

• 关于 Mermaid 语法，参考 这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图：

• 关于 Flowchart流程图 语法，参考 这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。

---

1. 注脚的解释 ↩︎