首页 > 其他分享 >线程之间的通信&线程池&设计模式

线程之间的通信&线程池&设计模式

时间:2023-10-15 19:32:26浏览次数:31  
标签:对象 通信 public 线程 Student new 设计模式 包子

day19_线程之间的通信&线程池&设计模式

课程目标

1. 【理解】线程通信概念
2. 【理解】等待唤醒机制
3. 【理解】线程池运行原理
4. 【理解】voliate关键字
5. 【掌握】单例设计模式

线程之间通信

什么是线程之间的通信

**概念:**多个线程在处理同一个资源,但是处理的动作(线程的任务)却不相同。

比如:线程A用来生成包子的,线程B用来吃包子的,包子可以理解为同一资源,线程A与线程B处理的动作,一个是生产,一个是消费,那么线程A与线程B之间就存在线程通信问题。

线程间通信

为什么要处理线程间通信

多个线程并发执行时, 在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信,以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源

多个线程在处理同一个资源,并且任务不同时,需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时, 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争(race),比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。就好比在公司里你和你的同事们,你们可能存在在晋升时的竞争,但更多时候你们更多是一起合作以完成某些任务。

就是在一个线程进行了规定操作后,就进入等待状态(wait()), 等待其他线程执行完他们的指定代码过后 再将其唤醒(notify());在有多个线程进行等待时, 如果需要,可以使用 **notifyAll()**来唤醒所有的等待线程。

wait/notify 就是线程间的一种协作机制。

  • 等待唤醒中的方法

    方法名 说明
    public final void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前,导致当前线程等待
    public final void notify() 唤醒在此对象监视器上等待的单个线程
    public final void notifyAll() 唤醒在此对象监视器上等待的所有线程

    wait:线程不再活动,不再参与调度,进入 wait set 中,因此不会浪费 CPU 资源,也不会去竞争锁了,这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作,也即是“通知(notify)”在这个对象上等待的线程从wait set 中释放出来,重新进入到调度队列(ready queue)中

    notify:则选取所通知对象的 wait set 中的一个线程释放;例如,餐馆有空位置后,等候就餐最久的顾客最先入座。

notifyAll:则释放所通知对象的 wait set 上的全部线程。

  • ==注意事项==

    哪怕只通知了一个等待的线程,被通知线程也不能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以她需要再次尝试去获取锁(很可能面临其它线程的竞争),成功后才能在当初调用 wait 方法之后的地方恢复执行。

    总结如下:

    • 如果能获取锁,线程就从 WAITING 状态变成 RUNNABLE 状态;
    • 否则,从 wait set 出来,又进入 entry set,线程就从 WAITING 状态又变成 BLOCKED 状态
  • waitnotify方法需要注意的细节

    • wait方法与notify方法必须要由同一个锁对象调用

      因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。

    • wait方法与notify方法是属于Object类的方法的

      因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。

    • wait方法与notify方法必须要在同步代码块或者是同步函数中使用

      因为:必须要通过锁对象调用这2个方法

生产者与消费者问题

等待唤醒机制其实就是经典的“生产者与消费者”的问题。

就拿生产包子消费包子来说等待唤醒机制如何有效利用资源:

包子铺线程生产包子,吃货线程消费包子。当包子没有时(包子状态为false),吃货线程等待,包子铺线程生产包子(即包子状态为true),并通知吃货线程(解除吃货的等待状态),因为已经有包子了,那么包子铺线程进入等待状态。接下来,吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁,那么就执行吃包子动作,包子吃完(包子状态为false),并通知包子铺线程(解除包子铺的等待状态),吃货线程进入等待。包子铺线程能否进一步执行则取决于锁的获取情况。

代码演示:

  • 包子资源类(共同的资源)

    public class BaoZi {
         String  pier ;
         String  xianer ;
         boolean  flag = false ;//包子资源 是否存在  包子资源状态
    }
    
  • 吃货线程类(消费者)

    public class ChiHuo extends Thread {
        private BaoZi bz;
        public ChiHuo(String name ,BaoZi bz) {
            super(name);
            this.bz = bz;
        }
    
        @Override
        public void run() {
            while (true){
                synchronized (bz){
                    if(bz.flag == false){//表示没有包子
                        try {
                            bz.wait();//消费者需要等待
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
    
                    //true表示有包子,就消费
                    System.out.println("消费正在吃:"+bz.pier+bz.xianer+" 的包子");
    
                    //消费完包子,修改包子的标记为false,表示没有包子
                    bz.flag = false;
    
                    //唤醒生产者线程
                    bz.notify();
                }
            }
        }
    }
    
    
  • 包子铺线程类(生产者)

    public class BaoZiPu extends Thread {
    
        private BaoZi bz;
        public BaoZiPu(String name ,BaoZi bz) {
            super(name);
            this.bz = bz;
        }
    
        @Override
        public void run() {
            int count = 0;
            while (true){
                synchronized (bz){
                    if(bz.flag == true){//true表示包子存在
                        try {
                            bz.wait();//生产者等一会
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
    
                    //没有包子, 生产包子
                    System.out.println("包子铺开始生产包子了!!");
                    if(count%2 ==0){
                        bz.pier ="荞麦皮";
                        bz.xianer ="荞麦馅";
                    }else{
                        bz.pier ="白面皮";
                        bz.xianer ="黑心馅";
                    }
                    count++;
                    //生产完修改包子标记为true,表示有包子
                    bz.flag = true;
                    System.out.println("包子铺开始卖包子了!快来消费吧!");
    
                    //唤醒 消费者
                    bz.notify();
                }
            }
        }
    }
    
    
  • 测试类

    public class Demo {
        public static void main(String[] args) {
            //共有包子资源,同理也是同一把锁
            BaoZi bz = new BaoZi();
    
            //生产者线程
            BaoZiPu bzp = new BaoZiPu("生产者",bz);
    
            //消费者线程
            ChiHuo ch = new ChiHuo("消费者",bz);
    
            bzp.start();
            ch.start();
    
        }
    }
    
  • 打印结果

    包子铺开始生产包子了!! 包子铺开始卖包子了!快来消费吧! 消费正在吃:荞麦皮荞麦馅 的包子

    包子铺开始生产包子了!! 包子铺开始卖包子了!快来消费吧! 消费正在吃:白面皮黑心馅 的包子

线程池

线程池思想

游泳池

​ 我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题:

如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。

那么有没有一种办法使得线程可以复用,就是执行完一个任务,并不被销毁,而是可以继续执行其他的任务?

在Java中可以通过线程池来达到这样的效果。今天我们就来详细讲解一下Java的线程池。

线程池概念

概念:其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源。

由于线程池中有很多操作都是与优化资源相关的,我们在这里就不多赘述。我们通过一张图来了解线程池的工作原理:

线程池原理

==合理利用线程池能够带来三个好处==

  1. 降低资源消耗。减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
  2. 提高响应速度。当任务到达时,任务可以不需要的等到线程创建就能立即执行。
  3. 提高线程的可管理性,可以得到复用。可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)。

线程池的使用

Java里面线程池的顶级接口是java.util.concurrent.Executor,但是严格意义上讲Executor并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService

要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,很有可能配置的线程池不是较优的,因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂,生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

Executors类中有个创建线程池的方法如下:

方法名 描述
public static ExecutorService newFixedThreadPool(int nThreads) 返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象,那么怎么使用呢,在这里定义了一个使用线程池对象的方法如下:

线程池中使用步骤

1. 创建线程池对象。
2. 创建Runnable接口子类对象。(task)
3. 提交Runnable接口子类对象。(take task)
4. 关闭线程池(一般不做)。

代码实现

  • Runnable实现类

    public class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("我要一个教练");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("教练来了: " + Thread.currentThread().getName());
            System.out.println("教我游泳,交完后,教练回到了游泳池");
        }
    }
    
  • 线程池测试类
    public class ThreadPoolDemo {
        public static void main(String[] args) {
            // 创建线程池对象,包含2个线程
            ExecutorService service = Executors.newFixedThreadPool(2);
            // 创建Runnable实例对象
            MyRunnable r = new MyRunnable();
    
            //自己创建线程对象的方式
            // Thread t = new Thread(r);
            // t.start(); ---> 调用MyRunnable中的run()
    
            // 从线程池中获取线程对象,然后调用MyRunnable中的run()
            service.submit(r);
            // 再获取个线程对象,调用MyRunnable中的run()
            service.submit(r);
            service.submit(r);
            // 注意:submit方法调用结束后,程序并不终止,是因为线程池控制了线程的关闭。
            // 将使用完的线程又归还到了线程池中
            // 关闭线程池
            //service.shutdown();
        }
    }
    

voliate关键字

volatile保证线程间变量的可见性,简单地说就是当线程A对变量X进行了修改后,在线程A后面执行的其他线程能看到变量X的变动,更详细地说是要符合以下两个规则:

  • ==线程对变量进行修改之后,要立刻回写到主内存。==
  • ==线程对变量读取的时候,要从主内存中读,而不是缓存==

image-20201208223734744

各线程的工作内存间彼此独立、互不可见,在线程启动的时候,虚拟机为每个内存分配一块工作内存,不仅包含了线程内部定义的局部变量,也包含了线程所需要使用的共享变量(非线程内构造的对象)的副本,即为了提高执行效率。

volatile是不错的机制,但是volatile不能保证原子性。

原子性是指在一个操作中就是cpu不可以在中途暂停然后再调度,既不被中断操作,要不执行完成,要不就不执行原子性就是指该操作是不可再分的。

代码演示

/**
 * volatile用于保证数据的同步,也就是可见性
 */
public class ThreadPoolDemo {    
    public static void main(String[] args) throws InterruptedException {
        MyThread t=new MyThread();
        t.start();
        //主线程休眠
        Thread.sleep(1000);

        t.stopMe();
    }
}
class MyThread extends Thread{
    private volatile boolean stop=false;
    public void stopMe(){
        stop=true;
    }

    @Override
    public void run() {
        int i=0;
        while (!stop) {
            i++;
        }
        System.out.println("Stop Thread!");
    }
}

使用volatile标识变量,将迫使所有线程均读写主内存中的对应变量,从而使得volatile关键字在多线程间可见。

设计模式

设计模式概述

image-20211115104937027

简单一句话:设计模式就是经验的总结

image-20211115104941612

创建型模式:简单工厂模式,工厂方法模式,抽象工厂模式,建造者模式,原型模式,单例模式。(6个)
结构型模式:外观模式、适配器模式、代理模式、装饰模式、桥接模式、组合模式、享元模式。(7个)
行为型模式:模版方法模式、观察者模式、状态模式、职责链模式、命令模式、访问者模式、策略模式、备忘录模式、迭代器模式、解释器模式。(10个)

什么是单例设计模式

单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。

总结一句话:在内存中只存在一个对象

单例模式

单例模式特点

  • 1、单例类只能有一个实例。也就是只有一个对象

  • 2、单例类必须自己创建自己的唯一实例。 写单例构造方法是要私有的

  • 3、单例类必须给所有其他对象提供这一实例。 在该方法中,提供一个方法,用于获取该对象

单例设计模式实现前提条件

  • 私有构造方法

  • 在本类的成员位置,创建出自己类对象

  • 提供公共方法,返回创建的对象 ,该方法必须是静态的

单例模式饿汉式

/*
* 单例模式饿汉式
*/
public class Student {
	// 构造私有
	private Student() {
	}
	// 自己造一个
	// 静态方法只能访问静态成员变量,加静态
	// 为了不让外界直接访问修改这个值,加private
	private static Student s = new Student();

	// 提供公共的访问方式
	// 为了保证外界能够直接使用该方法,加静态
	public static Student getStudent() {
		return s;
	}
}

测试

/*
 * 单例模式:保证类在内存中只有一个对象。
 * 
 * 如何保证类在内存中只有一个对象呢?
 * 		A:把构造方法私有
 * 		B:在成员位置自己创建一个对象
 * 		C:通过一个公共的方法提供访问
 */
public class StudentDemo {
	public static void main(String[] args) {
        //没有使用单例设计模式前,其实是多例
		// Student s1 = new Student();
		// Student s2 = new Student();
		// System.out.println(s1 == s2); // false

        //使用写好的单例设计模式,对象只有一个
		Student s1 = Student.getStudent();
		Student s2 = Student.getStudent();
		System.out.println(s1 == s2); // true

		System.out.println(s1); // null,cn.yanqi _03.Student@175078b
		System.out.println(s2);// null,cn.yanqi_03.Student@175078b
	}
}

单例模式懒汉式

/*
 * 单例模式:
 * 		饿汉式:类一加载就创建对象
 * 		懒汉式:用的时候,才去创建对象
 * 
 * 面试题:单例模式的思想是什么?请写一个代码体现。
 * 
 * 		开发:饿汉式(是不会出问题的单例模式)
 * 		面试:懒汉式(可能会出问题的单例模式)
 * 			A:懒加载(延迟加载)	
 * 			B:线程安全问题
 * 				a:是否多线程环境	是
 * 				b:是否有共享数据	是
 * 				c:是否有多条语句操作共享数据 	是
 */
public class Student {

    //1、构造方法私有
    private Student() {
    }

    //2、创建对象,并不是直接给出
    private static Student s = null;
    
    //3、对外提供公共的访问方法
    public  static Student getStudent(){
        if(s == null){
            s = new Student();
        }
        return s;
    }
    
}

测试

public class StudentDemo {
	public static void main(String[] args) {
		Student t1 = Student.getStudent();
		Student t2 = Student.getStudent();
		System.out.println(t1 == t2);
		System.out.println(t1); // cn.yanqi_03.Student@175078b
		System.out.println(t2);// cn.yanqi_03.Student@175078b
	}
}

单例模式懒汉式安全问题

单例模式懒汉式是一种对象延迟加载,在多线程情况可能会出现多例现象, 要想解决此问题,我们需要加同步代码块,进行解决

public class Student {

    //1、构造方法私有
    private Student() {
    }

    //2、创建对象,并不是直接给出
    private static Student s = null;

    //3、对外提供公共的访问方法
   public  static Student getStudent(){
        if(s == null){
            s = new Student();
        }
        return s;
    }

}
public static void main(String[] args) {

    new Thread(new Runnable() {
        @Override
        public void run() {
            Student s1 = Student.getStudent();
            System.out.println(s1);
        }
    }).start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            Student s2 = Student.getStudent();
            System.out.println(s2);
        }
    }).start();
    
}

多次测试,可以出会出多例情况发现

解决懒汉式安全问题

public class Student {

    //1、构造方法私有
    private Student() {
    }

    //2、创建对象,并不是直接给出
    private static Student s = null;

    //3、对外提供公共的访问方法
    // 方式一: 通过synchronized同步方法来解决线程安全问题,效率低
    public synchronized static Student getStudent(){
        if(s == null){
            s = new Student();
        }
        return s;
    }

    //=========================================
    //方式二 双重检查,效率高
    public static Student getStudent() {

        if (s == null) {//第一层检查,对象是否为null,确定要创建对,有一个进程

            synchronized (Student.class) {
                if (s == null) {
                    s = new Student();
                }
            }
        }
        return s;
    }
}


public class StudentTest {
    public static void main(String[] args) {

          new Thread(new Runnable() {
              @Override
              public void run() {
                  Student s1 = Student.getStudent();
                  System.out.println(s1);
              }
          }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                Student s2 = Student.getStudent();
                System.out.println(s2);
            }
        }).start();
    }
}

双层if判断的原因

  • 方法中加入同步锁,保证线程安全
  • 第二个线程调用方法getStudent()的时候,变量s,已经不是null,被前面的线程new过
  • 当已经有对象了,第二个线程没有必要再进入同步了,直接return返回对象即可

简单工厂设计模式

工厂设计模式,属于创建型,用于对象的创建; 简单来说:就是专门生产对象的

public abstract class Animal {
    public  abstract  void eat();
}
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("cat 吃 鱼");
    }
}
public class Dog extends  Animal {
    @Override
    public void eat() {
        System.out.println("dog 吃 肉");
    }
}
/**
 * @Desc  工厂设计类,这个类就是专门来生产对象,今后从这个工厂类中可以直接获取类对象
 */
public class AnimalFactory {
    private AnimalFactory(){}
    public static Dog createDog(){
        return new Dog();
    }
    public static Cat createCat(){
        return new Cat();
    }
}
/**
 * @Auther: yanqi
 * @Desc   工厂设计模式: 优点:我可以直接通过工厂来获取对象,集中管理对象
 *                      缺点:如果要加对象,需要修改工厂类,不便于后期的维护和扩展
 */
public class AnimalTest {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.eat();
        Dog d = new Dog();
        d.eat();

        //有了工厂之后,可以通过工厂来获取类对象
        Cat cat = AnimalFactory.createCat();
        cat.eat();
        Dog dog = AnimalFactory.createDog();
        dog.eat();
    }
}

模板设计模式

模版方法模式,简称为模板设计模式,它主要思想是:把通用的代码生成一个模板,可以反复的使用

/**
 * @Auther: yanqi
 * @Desc  生成了一个模板类
 */
public abstract class GetTime {
    //需求:请计算出一段代码所运行的时间
    public long getTime(){
        long start = System.currentTimeMillis();
       /*for (int i = 0; i <1000 ; i++) {
            System.out.println(i);
        }*/

        code();

        long end = System.currentTimeMillis();

        return end - start;
    }

    public abstract void code();
}
/**
 * @Auther: yanqi
 * @Desc  用户使用模板类
 */
public class ForDemo extends  GetTime {
    @Override
    public void code() {
        for (int i = 0; i <100 ; i++) {
            System.out.println(i);
        }
    }
}

/**
 * @Auther: yanqi
 * @Desc 测试
 */
public class Test {
    public static void main(String[] args) {
        GetTime gt = new ForDemo();
        System.out.println(gt.getTime()+"毫秒");
    }
}

装饰设计模式

装饰设计模式: 增强原有对象的功能

原本有一个对象,但是这个对象的功能不够强,采用装饰设计模式,对原对象中功能进行增强

回想一下我们当时讲的缓冲流,其实就是装饰设计模式

public class Phone {
    public void call(){
        System.out.println("手机打电话功能!");
    }
}
public class SendMsg {

    private Phone phone;

    public SendMsg( Phone phone){
        this.phone = phone;
    }

    //增强原有手机的功能
    public void msg(){
        System.out.println("发彩信");
        System.out.println("发短信");
        phone.call();
    }
}

public class Test {
    public static void main(String[] args) {
        //测试
        SendMsg sm = new SendMsg(new Phone());
        sm.msg();

        /*
        发彩信
        发短信
        手机打电话功能!
	*/
    }
}

面向对象思想设计原则

image-20211116093255798

单一职责原则

image-20211116093309950

能自己完成的事就不要麻烦别人,把一件事细化细化,只做一件事情

开闭原则 ocp

image-20211116093329509

里氏替换原则

image-20211116093339160

依赖注入原则

image-20211116093352012

接口分离原则

image-20211116093401975

迪米特原则

image-20211116093412497

标签:对象,通信,public,线程,Student,new,设计模式,包子
From: https://blog.51cto.com/teayear/7873067

相关文章

  • 线程
        ......
  • 线程的打断
    每个线程上都会有一个打断标记,默认是false,当别的线程打断某个线程后打断标记就会变为true。打断机制提供了一种让线程1更友好的去结束别的线程的方式:线程1打断线程2相当于给线程2发了一个信号,线程2自己决定收到这个信号时要做的处理。一、打断相关的方法和打断相关的方法......
  • 经典多线程题目
    1.三种线程按顺序执行publicclassTest1{//privatestaticLoggerlog=Logger.getLogger(Test2.class);publicstaticvoidmain(String[]args)throwsInterruptedException{//创建三个线程按照线程a,b,c执行Threada=newPrintThread()......
  • 线程操作控件
    privatevoidForm1_Load(objectsender,EventArgse){System.Threading.Threadthread=newSystem.Threading.Thread(CrossThreadFlush);thread.IsBackground=true;thread.Start();}privat......
  • STM32之CAN通信
    Can通信学习资料:正点原子CAN总线的学习瓶邪!-CAN详解前言LAN(即局域网)是最常见且应用最为广泛的一种网络,它是指在1~5公里范围内两台以上的计算机设备(如服务器、工作站)通过线缆(如同轴线缆、双绞线、光缆等)连接起来实现的资源共享的计算机网络,如家庭、办公室、学校或者有计......
  • 14.5 Socket 应用组播通信
    组播通信是一种基于UDP协议的网络通信方式,它允许发送方将消息同时传递给多个接收方。在组播通信中,发送方和接收方都会加入一个共同的组播组,这个组播组对应一个特定的IP地址,所有加入该组播组的主机都能够接收到发送方发送的消息。组播通信可以有效地减少网络流量和网络负载,因为在传......
  • 5G通信云/电信云资源池非SDN数通设备组网(拓扑图)
    现网实际组网:业务EOR和存管EOR会分开设置,详细组网详解明天再发。......
  • 设计模式总和
            ......
  • ArrayList线程安全问题分析
    测试代码:importjava.util.ArrayList;publicclassTestThreadSafe{staticfinalintLOOP_NUM=10;publicstaticvoidmain(String[]args)throwsInterruptedException{ThreadSafeSubClasstest=newThreadSafeSubClass();test.method1(......
  • 锁+多线程
     互斥锁mutex:保证共享数据操作的完整性,保证在任一时刻只能有一个线程访问对象。锁有两个操作。一个P操作(上锁),一个V操作(解锁)。P和V都是原子操作,就是在执行P和V操作时,不会被插队。锁一般使用信号量来实现的,mutex其实就是信号量=1。互斥量就是同一时间能够分给一个人,即S=1。S=......