1/25笔记

xianle1103

已于 2022-02-09 18:39:12 修改

阅读量85

点赞数

文章标签： java

于 2022-01-25 22:49:45 首次发布

本文链接：https://blog.csdn.net/xianle1103/article/details/122693368

版权

1 死锁
就是在执行过程中，都遇到了对方进入加锁的方法中，从而导致大家都访问不了的状态

死锁原理：

1）某一个线程执行完成，需要先后嵌套锁定，执行俩个对象，并在这个过程中，先锁定第一个对象

2）另外一个线程，执行完成，先后嵌套，锁定执行俩个对象，并且在这个过程中，先锁定第二个对象

3）在第一个线程执行到第二个对象的时候，发现已经被锁定，只能等待

4）在第二个线程执行到第一个对象的时候，发现已经被锁定只能等等待

public static void main(String[] args){
       Object o1 = new Object();
       Object o2 = new Object();
       Thread t1 = new Thread(new A1(o1,o2));
       Thread t2 = new Thread(new A2(o1,o2));
       t1.setName("t1");
       t2.setName("t2");
       t1.start();
       t2.start();
   }
}
class A1 implements Runnable{
   Object o1;
   Object o2;
   public A1(Object o1, Object o2) {
       super();
       this.o1 = o1;
       this.o2 = o2;
   }
   @Override
   public void run() {
       synchronized(o1){
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           synchronized(o2){
               System.out.println(Thread.currentThread().getName()+"执行完成");
           }
       }
   }
}
class A2 implements Runnable{
   Object o1;
   Object o2;
   public A2(Object o1, Object o2) {
       super();
       this.o1 = o1;
       this.o2 = o2;
   }
   @Override
   public void run() {
       synchronized(o2){
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           synchronized(o1){
               System.out.println(Thread.currentThread()+"执行完成");
           }
       }

   }

2 线程通信

2.1 概述

wait: 让该线程进入等待状态，会释放持有的锁

无参或者传入0 表示一直等待不会自动唤醒，只能等着notify唤醒

也可以传入long类型的值，类似于sleep 时间到了自己唤醒

notify: 随机唤醒一个在该对象中正在等待的一个线程

notifyAll: 唤醒在该对象中所有等待的线程

以上方法只能用在加锁的成员方法中

2.2 使用方式

如打印奇数和偶数

public class Thread_02_wait {
       public static void main(String[] args){
           Num num = new Num();
           Thread t1 = new PrintEven(num);
           Thread t2 = new PrintOdd(num);
           t1.setName("t1");
           t2.setName("t2");
           t1.start();
           t2.start();
       }
}
//打印偶数
class PrintEven extends Thread{
   Num num;

   public PrintEven(Num num) {
       super();
       this.num = num;
   }
   @Override
   public void run(){
       while(true){
           num.printEven();
       }
   }
}
//打印奇数
class PrintOdd extends Thread{
   Num num;

   public PrintOdd(Num num) {
       super();
       this.num = num;
   }
   @Override
   public void run(){
       while(true){
           num.printOdd();
       }
   }
}
class Num{
   int count = 1;
   public synchronized void printOdd(){
       System.out.println(Thread.currentThread().getName()+"--->"+count);
       count++;
       //唤醒其他线程，取打印偶数
       this.notifyAll();
       //进入等待
       try {
           Thread.sleep(500);
           this.wait();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
   public synchronized void printEven(){
       System.out.println(Thread.currentThread().getName()+"-->"+count);
       count++;
       //唤醒其他线程，打印奇数
       this.notifyAll();
       //进入等待
       try {
           Thread.sleep(500);
           this.wait();
       } catch (InterruptedException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }

   }
}

2.3 生产者消费者

package Day2;

import java.util.Random;

/**
* 生产者消费者
* 1 定义一个业务类SynStack ，其中有一个变量，用来保存已产生的元素个数
* 2 业务类中有一个 char数组，用于保存生产的元素（假如只生产 a-z）
* 3 业务类中需要有俩个方法：一个是生产push 一个是消费pop
*                        push方法主要用于向数组中添加数据
*                                        个数+1，还要判断是否添加满了，满了就挂起进入等待
*                        pop方法主要用于取出数组中数据
*                                        个数-1，还要判断是否消费完了，完了就挂起等待
*/
public class Thread_03 {
       public static void main(String[] args){
           SynStack1 ss =new SynStack1();
           Thread p = new Thread(new Producer(ss));
           Thread c = new Thread(new Consumer(ss));
           p.start();
           c.start();
       }
}
class Producer implements Runnable{
   SynStack1 ss;

   public Producer(SynStack1 ss) {
       super();
       this.ss = ss;
   }

   @Override
   public void run() {
       Random random = new Random();
   while(true){
       char ch =(char)(random.nextInt(26)+97);
       ss.push(ch);
   }

   }
}
class Consumer implements Runnable{
   SynStack1 ss;

   public Consumer(SynStack1 ss) {
       super();
       this.ss = ss;
   }

   @Override
   public void run() {
       while(true){
       try {
           Thread.sleep(600);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       ss.pop();
   }
}
}
class SynStack1{
   //保存数据的容器
   char[] data = new char[6];
   //生产个数
   int count = 0;
   //生产
   public synchronized void push(char ch){
       //判断是否满了
       if(count == data.length){
           try{
               this.wait();
           }catch(InterruptedException e){
               e.printStackTrace();
           }
       }
       // 到这里，说明没有满，开始生产
       //唤醒消费者消费
       this.notifyAll();
       data[count] = ch;
       count++;
       System.out.println("生产了" +ch +",剩余"+count+"个元素");
   }
   public synchronized char pop(){
       //判断是否为空
       if(count == 0){
           try{
               //不用唤醒生产者，因为生产者是满了在wait,都为空，说明生产者肯定没有wait
               this.wait();
           }catch(InterruptedException e){
               e.printStackTrace();
           }
       }
       //到这里说明不是空，开始消费
       count--;
       char ch = data[count];
       //唤醒生产者
       this.notifyAll();
       System.out.println("消费了" +ch+",剩余" +count +"个元素");
       return ch;
   }

}

3 单例模式

让某个类只实例化一个对象

构造方法私有化，静态变量保存对象，公共的静态方法用于获取类对象

饿汉安全模式

public class Thread_04 {
   private Thread_04(){

   }
   //饿汉
   private static Thread_04 singLeton = new Thread_04();
   public static Thread_04 getInstance() {
       return singLeton;
   }
}
懒汉安全模式

public class Thread_05 {
   private Thread_05(){

   }
//   private static Thread_05 singLeton = null;
//   //效率低，因为每次都需要排队
//   public synchronized static Thread_05 getInstance(){
//       if(singLeton == null){
//           singLeton = new Thread_05();
//       }
//       return singLeton;
//
//   }
   //volatile：加它防止指令重排
   private volatile static Thread_05 singLeton = null;
   //效率较高，因为只需要第一次排队
   public static Thread_05 getInstance(){
       //双重校验
       if(singLeton == null){
           synchronized(Thread_05.class){
               if(singLeton == null){
           singLeton = new Thread_05();
       }
       }
       }
       return singLeton;

   }
}
4 线程池