JAVAEE初阶第二节——多线程基础(下)

于 2024-09-01 19:57:30 发布
阅读量495 收藏 9
点赞数 17
分类专栏： JavaEE初阶 文章标签： java-ee java 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79418684/article/details/136570865
版权

系列文章目录

JAVAEE初阶第二节——多线程基础(下)

多线程基础(下)

  1. 单例模式
  2. 阻塞式队列
  3. 定时器
  4. 线程池

文章目录

一.多线程案例

1.单例模式

单例模式是一种非常重要的设计模式之一
设计模式好比象棋中的 “棋谱”. 红方当头炮, 黑方马来跳. 针对红方的一些走法, 黑方应招的时候有一些固定的套路. 按照套路来走局势就不会吃亏.
软件开发中也有很多常见的 “问题场景”. 针对这些问题场景, 大佬们总结出了一些固定的套路. 按照这个套路来实现代码, 也不会吃亏.

单例模式能保证某个类在程序中只存在唯一一份实例, 而不会创建出多个实例.

单例模式具体的实现方式, 分成 “饿汉” 和 “懒汉” 两种

1.1 饿汉模式

类加载的同时, 创建实例.

class Singleton{  
	private static Singleton instance = new Singleton();  
	public static Singleton getInstance(){  
	return instance;  
    }   
	private Singleton(){  
	}  
}

上述代码，称为“饿汉模式”，是单例模式中一种简单的写法所谓"饿"形容"非常迫切”，是指实例是在类加载的时候就创建了，创建时机非常早，相当于程序一启动，实例就创建了。就使用"饿汉"形容"创建实例非常迫切，非常早"。

  1. 这个引用，就是期望创建出的唯一的实例的引用（static静态的指的是"类属性"，instance就是Singleton类对象里面持有的属性）。每个类的类对象，只存在一个。类对象中的static属性，自然也是只有一个了。因此，instance指向的这个对象，就是唯一的一个对象！
private static Singleton instance = new Singleton();
  1. 其他代码要想使用这个类的实例就需要通过这个方法来进行获取。不应该在其他代码中重新new这个对象，而是使用getInstance()方法获取到现成的对象(已经创建好的唯一的对象，不是Thread)
  2. Singleton内部的代码早就把唯一的实例安排好了。
public static void main(String[] args) {  
	Singleton singleton1 = Singleton.getInstance();  
	Singleton singleton2 = Singleton.getInstance();  
	System.out.println(singleton1 == singleton2);  
}

在这里插入图片描述

1.2 懒汉模式

懒汉模式与饿汉模式相比，创建实例的时机不太一样了创建实例的时机会更晚，只到第一次使用的时候，才会创建实例。社会能进步，科技能发展，效率生产力能提高，归根结底，都是因为"懒"。在计算机中，所谓的"懒”往往代表着"更高的效率"

1.2.1 懒汉模式-单线程版
class SingletonLazy{  
	private static SingletonLazy instance = null;  
	private SingletonLazy(){  
	}  
	public static SingletonLazy getInstance(){  
		if(instance == null){  
			instance = new SingletonLazy();  
		}  
		return instance;  
	}  
}

如果是首次调用getlnstance,那么此时instance引用为null,就会进入if条件，从而把实例创建出来。
如果是后续再次调用getlnstance,由于instance已经不再是null此时不会进入if,直接返回之前创建好的引用了。
这样设定，仍然可以保证，该类的实例是唯一的一个。与此同时，创建实例的时机就不是程序驱动时了，而是第一次调用getlnstance的时候。（调用getlnstance的时间是未知的，什么时候调用（第一次），什么时候在创建实例。如果整个程序都被调用，就可以把创建实例的操作省去了。）

public static void main(String[] args) {  
	SingletonLazy singletonLazy1 = SingletonLazy.getInstance();  
	SingletonLazy singletonLazy2 = SingletonLazy.getInstance();  
	System.out.println(singletonLazy2 == singletonLazy1);  
}

在这里插入图片描述

1.2.3 懒汉模式-多线程版

之前写的饿汉模式和懒汉模式在多线程环境下是否线程安全呢？

对于饿汉模式来说：getInstance直接返回的是instance实例，这个操作的本质是“读操作”，
而多线程读取同一个变量，是线程安全的

对于懒汉模式来说：因为懒汉模式中有读操作，也有写操作。所以如果两个线程按照下面的顺序执行就会出现一些问题
在这里插入图片描述

thread1先执行，if判断成功，进入if语句后，thread1停止。thread2开始执行，此时还没有创建实例于是进入if语句并创建一个实例。thread2结束，thread1继续刚才的操作，根据上下文得知还没有创建实例（此时已经有了一个实例），于是就创建一个实例。这样就会导致最终这两个线程创建了两个不同的实例，这就违反了单例模式的规则，是有问题的。

懒汉模式的改进（多线程）

加锁将if判定和new打包成“原子”的

class SingLetonLazy {  
	private static SingLetonLazy instance = null;  
	private static Object locker = new Object();  
	private SingLetonLazy(){  
	}  
	public static SingLetonLazy getInstance(){  
		synchronized(locker){  
			if(instance == null){  
				instance = new SingLetonLazy();  
			}  
		}  
		return instance;  
	}  
}

此时就可以保证一定是thread1执行完new操作，执行完修改Instance之后，再回到thread2执行f,thread2的if条件就不会成立了。t2就会直接返回了。

但是上面的代码还是有一点问题，如果Instance已经创建过了。此时后续再调用getlnstance就都是直接返回Instance实例了。(此处的操作就是纯粹的读操作了，也就不会有线程安全问题了)此时，针对这个已经没有线程安全问题的代码，仍然是每次调用都先加锁，再解锁，此时，效率就非常低了。（加锁就意味着可能会产生阻塞）
所以要在需要加锁的时候才加锁，不该加锁，不能随便乱加。

这时候就可以在加锁外头再套上一层if,判定一下这个代码是否需要加锁。如果需要加锁，才加。如果不需要加锁，就不加锁。

class SingLetonLazy {  
	private static SingLetonLazy instance = null;  
	private static Object locker = new Object();  
	private SingLetonLazy(){  
	}  
	public static SingLetonLazy getInstance(){  
		if(instance == null){  //判断是否要加锁
			synchronized(locker){  
				if(instance == null){  //判断是否要创建对象
					instance = new SingLetonLazy();  
				}  
			}  
		}  
		return instance;  
	}  
}

上面代码中的第一个if判定的是否要加锁，第二个if判定的是是否要创建对象（这两个if的判断条件是相同的）

指令重排序引起线程安全问题

上面代码还是有点问题，因为指令重排序引起的线程安全问题
指令重排序，也是编译器优化的一种方式。即调整原有代码的执行顺序，保证逻辑不变的前提下，提高程序的效率。

	instance = new SingLetonLazy();

上面这段代码其实还可以拆成三个大的步骤
步骤1：申请一段空间
步骤2：在这个内存上调用构造方法，创建出这个实例
步骤3：把这个内存地址赋值给Instance引用变量

会引起线程安全问题的分析：
thread1会按照步骤1->步骤3->步骤2来执行这里的new操作。
在这里插入图片描述

当thread1的instance = new SingLetonLazy(); 执行到步骤3时（被优化成1,3,2的执行顺序），thread2开始执行，因为此时已经instance有一个未初始化对象的引用，所以thread2没有进入if触发加锁，也没有阻塞就直接返回了这个instance。此时所以instance里面的属性或者方法就有可能出现错误。（此时的instance的属性是一个未初始化的值）

过程总结：上面代码执行过程由于thread1线程执行完步骤1和步骤3后被调度走，此时的instance指向的是一个不为nul的值（未初始化对象）。此时thread2线程判断instance == null就不处理，直接返回。如果thread2继续使用instance里面的属性或者方法，就会出现问题（因为此时的属性都是未初始化的“全0”值），引起代码的逻辑出现问题。

要想解决这个问题，就可以使用volatile（保证内存可见性，禁止指令重排序）

其他地方不变

private volatile static SingLetonLazy instance = null;

2.阻塞式队列

2.1 阻塞队列的概念

阻塞队列是一种特殊的队列. 也遵守 “先进先出” 的原则.
（1）阻塞队列是一种线程安全的数据结构。
（2）具有阻塞特性：

  • 如果针对一个已经满了的队列进行入队列，此时入队列操作就会阻塞。一直阻塞到队列不满（其他线程出队列元素）之后。
  • 如果针对一个已经空了的队列进行出队列，此时出队列操作就会阻塞。一直阻塞到队列不空（其他线程入队列元素）之后

阻塞队列的一个典型应用场景就是 “生产者消费者模型”. 这是一种非常典型的开发模型.

2.2 生产者消费者模型

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。
生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取.

生产者消费者模型的作用：

  1. 阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力
  2. 阻塞队列也能使生产者和消费者之间解耦.

把代码的耦合程度，从高降低，就称为解耦合。

  1. 引入生产者消费者模型，就可以更好的做到"解耦合"

实际开发中，经常会涉及到"分布式系统”。（服务器整个功能不是由一个服务器全部完成的。而是每个服务器负责一部分功能通过服务器之间的网络通信，最终完成整个功能）

在这里插入图片描述

上面的模型中，A和B，A和C之间的耦合性就是比较强的。（A/B的代码中涉及到和B/A的一些相关操作,C/A的代码中涉及到和A/C的一些相关操作。B或C任意一个出了问题，对A都会有很大的影响。）

在这里插入图片描述

此时A和B，A和C都不再是直接交互了，而是通过队列来传递信息。（A只需要和队列交互，B、C也只需要和队列交互，B，C的存亡对A来说就没那么重要了（解耦合））
（1）上述描述的阻塞队列，并非是简单的数据结构。而是基于这个数据结构实现的服务器程序。
（2）整个系统的结构更复杂了,要维护的服务器就更多了
（3）效率在一定程度上变低了。请求从A发出来到B收到，这个过程中就经历队列的转发
这个过程中也是有一定开销的。

  1. 削峰填谷(此处所谓的峰谷都不是长时间持续的，而是短时间出现的）
    在这里插入图片描述

一旦外界的请求出现了突发的峰值，就会影响到B、C服务器（严重情况下可能服务器直接挂了）。
A服务器的工作比较简单，每个请求消耗的资源相对较少。
B服务器（用户服务器）要从数据库中查找到对应的用户信息，消耗资源较多。请求过多的时候可能出问题。
C服务器（商品服务器）要从数据库中查找到对应的商品信息，有时还要对商品信息进行筛选。消耗资源较多，请求过多的时候可能出问题。

在这里插入图片描述

引入队列，就可以有效地防止B，C服务器因为请求过多而出现问题。
队列不实习业务逻辑，只是用来存储数据的，即使外界的请求出现峰值，也有一定的能力来承担。B，C按照原来的速度正常取数据即可。

2.3标准库中的阻塞队列

在 Java 标准库中内置了阻塞队列. 如果我们需要在一些程序中使用阻塞队列, 直接使用标准库中的即可。

  • BlockingQueue 是一个接口. 真正实现的类是 LinkedBlockingQueue.
  • put 方法用于阻塞式的入队列, take 用于阻塞式的出队列.
  • BlockingQueue 也有 offer, poll, peek 等方法, 但是这些方法不带有阻塞特性
BlockingQueue<String> queue = new LinkedBlockingQueue<>();  
// 入队列  
queue.put("abc");  
// 出队列. 如果没有 put 直接 take, 就会阻塞.  
String elem = queue.take();

2.4 阻塞队列的实现

  1. 先实现普通队列

先实现一个基于数组的环形队列

class MyBlockingQueue{  
	private String[] elems = null;  
	private int head = 0;  
	private int tail = 0;  
	private int size = 0;//队列当前元素数目  
	public MyBlockingQueue(int capacity){  
		elems = new String[capacity];  
	}  
	public void put(String element){  
		if(size > elems.length){//队列满了  
			//暂时不做处理，先完成一个普通队列  
			//后面再在这里做阻塞处理  
			return;  
		}  
		elems[tail++] = element;//新的元素放到tail指向的位置。  
		if(tail >= elems.length){
			tail = 0;  
			}  
		size++;  
	}  
	public String take(){  
		if(size == 0){  
		    //暂时不做处理，先完成一个普通队列  
			//后面再在这里做阻塞处理  
			return null; //队列为空  
		}  
		String element = elems[head++];//队头元素出队列  
		if(head >= elems.length){
			head = 0;  
		}  
		size--;  
		return element;  
	}  
}

public static void main(String[] args) {  
	MyBlockingQueue BQ = new MyBlockingQueue(2000);  
	BQ.put("1");  
	BQ.put("2");  
	BQ.put("3");  
	BQ.put("4");  
	BQ.put("5");  
	BQ.put("6");  
	  
	String elem = " ";  
	elem = BQ.take();  
	System.out.println("elem :" + elem);  
	elem = BQ.take();  
	System.out.println("elem :" + elem);  
	elem = BQ.take();  
	System.out.println("elem :" + elem);elem = BQ.take();  
	System.out.println("elem :" + elem);  
  
}

在这里插入图片描述

多线程情况下，假设elems的大小为10，此时此时thread1正在添加最后一个元素，同时thread2也在尝试添加元素，如果按下面的顺序就会出现线程安全问题:

在这里插入图片描述

thread1先执行，此时队列还没有满于是不进入if语句返回，继续向下执行。此时thread1被调度走，thread2开始执行，因为thread1还没有开始入队列的操作，所以，此时队列还没有满于是不进入if语句返回，继续向下执行。此时thread1继续执行，进行入队列的操作后，队列这时就是满的情况，但是thread2开始执行的时候会继续刚才的操作，入队列。这时之前入队列的最后一个元素就会被覆盖并且size也会超过队列长度。（take操作同理，也有上面问题）
这时就可以通过加锁来解决。

  1. 完善线程安全

要阻塞的地方和写操作的地方都要加锁。

class MyBlockingQueue{  
	private String[] elems = null;  
	private int head = 0;  
	private int tail = 0;  
	private int size = 0;//队列当前元素数目  
	public MyBlockingQueue(int capacity){  
		elems = new String[capacity];  
	}  
	private Object locker = new Object();//锁对象  
	public void put(String element){  
		synchronized(locker){  
			if(size > elems.length){//队列满了  
				//暂时不做处理，先完成一个普通队列  
				//后面再在这里做阻塞处理  
				return;  
			}  
			elems[tail++] = element;//新的元素放到tail指向的位置。  
			if(tail >= elems.length){  
				tail = 0;  
			}  
			size++;  
		}  
	}  
	public String take(){  
		String element = null;  
		synchronized (locker){  
			if(size == 0){  
				//暂时不做处理，先完成一个普通队列  
				//后面再在这里做阻塞处理  
				return null; //队列为空  
			}  
			element = elems[head++];//队头元素出队列  
			if(head >= elems.length){  
				head = 0;  
			}  
			size--;  
		}  
		return element;  
	}  
}

队列满了后再入队列就需要阻塞。当元素出队列的时候唤醒。
队列空了后，再出队列就需要阻塞。当元素入队列的时候唤醒。

  1. 实现阻塞。
class MyBlockingQueue{  
	private String[] elems = null;  
	private int head = 0;  
	private int tail = 0;  
	private int size = 0;//队列当前元素数目  
	public MyBlockingQueue(int capacity){  
		elems = new String[capacity];  
	}  
	private Object locker = new Object();//锁对象  
	public void put(String element) throws InterruptedException {  
		synchronized(locker){  
			if(size > elems.length){//队列满了  
				//暂时不做处理，先完成一个普通队列  
				locker.wait();//后面再在这里做阻塞处理  
			}  
			elems[tail++] = element;//新的元素放到tail指向的位置。  
			if(tail >= elems.length){  
				tail = 0;  
			}  
			size++;  
			locker.notify();//入队列成功后唤醒。  
		}  
	}  
	public String take() throws InterruptedException {  
		String element = null;  
		synchronized (locker){  
			if(size == 0){  
				//暂时不做处理，先完成一个普通队列  
				locker.wait();//后面再在这里做阻塞处理  
			}  
			element = elems[head++];//队头元素出队列  
			if(head >= elems.length){  
				head = 0;  
			}  
			size--;  
			  
			locker.notify();//出队列成功后唤醒。  
		}  
		return element;  
	}  
}

但是上面的代码在多线程的情况下也会出现一种问题，入队列的唤醒操作可能会唤醒其他等待入队列的操作：
如果队列满了，此时又正好有同时有三个线程thread1，thread2，thread3。其中thread1和thread2都是执行put操作，都会进入wait阻塞状态（即使加锁了，第一个线程wait后就会释放锁，所以第二个线程也会进入wait阻塞状态）。此时thread3执行take操作，结束后将thread1从wait中唤醒，thread1执行入队列操作（队列再次满），执行到locker.notify();后又将thread2从wait中唤醒，可是此时队列已经满了，再入就会出现和之前一样的问题。

在这里插入图片描述

这种问题会出现的原因是用if来判断一次是否需要阻塞是远远不够的。在多线程的情况下，每次进入阻塞到被唤醒之间都会发生很多变数这个时候就难以保证此时还是不是满足wait的条件了。所以我们要在唤醒后再做一次判断，就能避免这个情况了。
这里可以将if语句变为while语句。这样就可以实现wait之前确定一次条件，wait被唤醒之后还能判断一次条件。（而且JAVA标准库也是推荐这么使用wait的）

在这里插入图片描述

阻塞队列：

class MyBlockingQueue{  
	private String[] elems = null;  
	private int head = 0;  
	private int tail = 0;  
	private int size = 0;//队列当前元素数目  
	public MyBlockingQueue(int capacity){  
		elems = new String[capacity];  
	}  
	private Object locker = new Object();//锁对象  
	public void put(String element) throws InterruptedException {  
		synchronized(locker){  
			while(size > elems.length){//队列满了  
				//暂时不做处理，先完成一个普通队列  
				locker.wait();//后面再在这里做阻塞处理  
			}  
			elems[tail++] = element;//新的元素放到tail指向的位置。  
			if(tail >= elems.length){  
				tail = 0;  
			}  
			size++;  
			locker.notify();//入队列成功后唤醒。  
		}  
	}  
	public String take() throws InterruptedException {  
		String element = null;  
		synchronized (locker){  
			while(size == 0){  
				//暂时不做处理，先完成一个普通队列  
				locker.wait();//后面再在这里做阻塞处理  
			}  
			element = elems[head++];//队头元素出队列  
			if(head >= elems.length){  
				head = 0;  
			}  
			size--;  
			  
			locker.notify();//出队列成功后唤醒。  
		}  
		return element;  
	}  
}

3. 定时器

定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定好的代码。

3.1 标准库中的定时器

  • 标准库中提供了一个 Timer 类. Timer 类的核心方法为 schedule .
  • schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后执行 (单位为毫秒)
public static void main(String[] args) {
	Timer timer = new Timer();
	timer.schedule(new TimerTask(){
			@Override
			public void run() {//时间到了就会执行run里的代码
				System.out.println("timer：3000");
			}
		}, 3000);

	timer.schedule(new TimerTask(){
			@Override
			public void run() {
				System.out.println("timer：2000");
			}
		}, 2000);


	timer.schedule(new TimerTask(){
			@Override
			public void run() {
				System.out.println("timer：1000");
			}
		}, 1000);

	System.out.println("main");
	System.out.println("timer 结束");
	timer.cancel();//需要使用cancel主动结束。否则Timer不知道是否其他地方还要继续添加任务.
}

运行结果

3.2 实现定时器

定时器就是可以在指定的时间，去执行某个任务（执行某一段代码）。要想实现一个定时器，就先要理解schedule的作用：把一个任务(TimerTask)添加到定时器中。定时器内部有一个线程，就会在任务时间到的时候，调用任务对应的代码。
其次还要明白定时器的构成
1）需要有一个线程，负责帮计时。等任务到达合适的时间，这个线程就负责执行。
2）需要一个带优先级的阻塞队列用来保存所有的任务。

  1. 使用MyTimerTask类（实现Comparable 接口）用于描述一个任务.

（1）需要一个 Runnable 对象（用来接受要执行的任务（run方法里的代码））
（2）需要一个time(用来表示执行任务的相对时间（毫秒时间戳)）。
（3）需要一个getTime方法来获取执行任务的时间。
（4）需要一个构造方法来初始化Runnable和time（当前时间加上执行任务的相对时间得到的真正执行任务的绝对时间）
（5）需要一个run来执行任务
（6）重写compareTo方法（将时间短的任务放在前面）

有些集合类，是对于元素有特定要求的PriorityQueue,TreeMap,TreeSet.都要求元素是"可比较大小。Comparable,ComparatorHashMap,HashSet,则是要求元素是"可比较相等""可hash的"
2. 使用MyTimer类来表示一个定时器

（1）需要一个Thread对象用来负责扫描任务队列，执行任务。
（2）需要一个阻塞队列（其中的元素是MyTimerTask类）来作为优先级任务队列（优先级在MyTimerTask类中实现（实现 Comparable 接口））
（3）需要一个schedule方法，创建一个 MyTimeTask 对象接收任务内容和时间，并将这个 MyTimeTask 对象放进队列中。
（4）需要一个构造方法，创建扫描线程，让扫描线程来完成判定和执行。

class MyTimeTask implements Comparable<MyTimeTask> {
    private long time;//执行任务的时间（ms级别的时间戳）
    private Runnable runnable;//要执行的任务（run方法里的代码）
    public long getTime() {
        return time;
    }
    public MyTimeTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        time = System.currentTimeMillis() + delay;//当前时间加上执行任务的相对时间就是真正执行任务的绝对时间。
    }

    public void run() { //执行任务
        runnable.run();
    }

    @Override
        public int compareTo(MyTimeTask o) {
        return (int)(this.time - o.time);
    }
}
class MyTimer {
    private Thread thread = null;//负责扫描任务队列，执行任务的线程
    private PriorityQueue<MyTimeTask> tasksQueue = new PriorityQueue<>();//任务队列

    public void  schedule(Runnable runnable, long delay) {
        MyTimeTask task = new MyTimeTask(runnable, delay);
        tasksQueue.offer(task);
    }
    public MyTimer() {//扫描线程就需要循环的反复的扫描队首元素，然后判定队首元素是不是时间到了，
        //如果时间没到，啥都不干,如果时间到了，就执行这个任务并且把这个任务从队列中删除掉，
        thread = new Thread(()->{
            while (true) {
                if (tasksQueue.isEmpty()) {//队列空了
                    //暂时不做处理
                    continue;
                }
                MyTimeTask task = tasksQueue.peek();//队列不为空，取出队首元素
                long curTime = System.currentTimeMillis();
                if (curTime >= task.getTime()) {//时间到了，可以完成任务了
                    tasksQueue.poll();
                    task.run();
                }
                else {
                    //时间还没到，暂时不处理。
                    continue;
                }
            }
        });
      thread.start();
    }
}

但是上面的代码还要解决两个比较关键的问题
（1）线程安全

如果我们在主线程中对于队列中的元素进行添加，在其他线程中要在执行完任务后删除队列中的元素。两个不同的线程操作一个相同的任务队列 。多个线程操作同一个变量就会有线程安全问题。所以要加锁来解决。

其他地方一样

class MyTimer {
	private Thread thread = null;//负责扫描任务队列，执行任务的线程
	private PriorityQueue<MyTimeTask> tasksQueue = new PriorityQueue<>();//任务队列

	private Object locker = new  Object();//创建一个锁对象
	public void  schedule(Runnable runnable, long delay) {
		synchronized(locker) {
			MyTimeTask task = new MyTimeTask(runnable, delay);
			tasksQueue.offer(task);
		}
	}
	public MyTimer() {//扫描线程就需要循环的反复的扫描队首元素，然后判定队首元素是不是时间到了，
		//如果时间没到，啥都不干,如果时间到了，就执行这个任务并且把这个任务从队列中删除掉，
		thread = new Thread(()->{
			while (true) {
				synchronized(locker) {//在while里加锁避免循环不能结束导致锁无法被释放
					if (tasksQueue.isEmpty()) {//队列空了
						//暂时不做处理
						continue;
					}
					MyTimeTask task = tasksQueue.peek();//队列不为空，取出队首元素
					long curTime = System.currentTimeMillis();
					if (curTime >= task.getTime()) {//时间到了，可以完成任务了
						tasksQueue.poll();
						task.run();
					}
					else {
						//时间还没到，暂时不处理。
						continue;
					}
				}//解锁
			}
		});
	thread.start();	
	}
}

（2）线程饿死
while循环里，解锁之后，立即又重新尝试加锁了导致其他线程通过schedule想加锁，但是加不上（线程饿死）.这时就可以用wait和notify

class MyTimer {
	private Thread thread = null;//负责扫描任务队列，执行任务的线程
	private PriorityQueue<MyTimeTask> tasksQueue = new PriorityQueue<>();//任务队列

	private Object locker = new Object();//创建一个锁对象

	public void schedule(Runnable runnable, long delay) {
		synchronized(locker) {
			MyTimeTask task = new MyTimeTask(runnable, delay);
			tasksQueue.offer(task);
			locker.notify();//添加新的元素之后，就可以唤醒扫描线程的wait了
		}
	}

	public MyTimer() {//扫描线程就需要循环的反复的扫描队首元素，然后判定队首元素是不是时间到了，
		//如果时间没到，啥都不干,如果时间到了，就执行这个任务并且把这个任务从队列中删除掉，
		thread = new Thread(() -> {
			while (true) {
				try {
					synchronized(locker) {//在while里加锁避免循环不能结束导致锁无法被释放
						while (tasksQueue.isEmpty()) {//队列空了
							locker.wait();//避免循环导致线程饿死
						}
						MyTimeTask task = tasksQueue.peek();//队列不为空，取出队首元素
						long curTime = System.currentTimeMillis();
						if (curTime >= task.getTime()) {//时间到了，可以完成任务了
							tasksQueue.poll();
							task.run();
						}
						else {
							//当前时间还没到，暂时先不执行
							//不能使用sleep,会错过新的任务，也无法释放锁。
							locker.wait(task.getTime() - curTime);//解决“忙等”，时间没到却一直执行前面的判断
						}
					}//解锁
				}
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread.start();
	}
}

在这里插入图片描述

定时器：

class MyTimeTask implements Comparable<MyTimeTask> {
    private long time;//执行任务的时间（ms级别的时间戳）
    private Runnable runnable;//要执行的任务（run方法里的代码）
    public long getTime() {
        return time;
    }
    public MyTimeTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;//当前时间加上执行任务的相对时间就是真正执行任务的绝对时间。
    }

    public void run() { //执行任务
        runnable.run();
    }

    @Override
        public int compareTo(MyTimeTask o) {
        return (int)(this.time - o.time);
    }
}
class MyTimer {
    private Thread thread = null;//负责扫描任务队列，执行任务的线程
    private PriorityQueue<MyTimeTask> tasksQueue = new PriorityQueue<>();//任务队列

    private Object locker = new Object();//创建一个锁对象

    public void schedule(Runnable runnable, long delay) {
        synchronized(locker) {
            MyTimeTask task = new MyTimeTask(runnable, delay);
            tasksQueue.offer(task);
            locker.notify();//添加新的元素之后，就可以唤醒扫描线程的wait了
        }
    }

    public MyTimer() {//扫描线程就需要循环的反复的扫描队首元素，然后判定队首元素是不是时间到了，
        //如果时间没到，啥都不干,如果时间到了，就执行这个任务并且把这个任务从队列中删除掉，
        thread = new Thread(() -> {
            while (true) {
                try {
                    synchronized(locker) {//在while里加锁避免循环不能结束导致锁无法被释放
                        while (tasksQueue.isEmpty()) {//队列空了
                            locker.wait();//避免循环导致线程饿死
                        }
                        MyTimeTask task = tasksQueue.peek();//队列不为空，取出队首元素
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task.getTime()) {//时间到了，可以完成任务了
                            tasksQueue.poll();
                            task.run();
                        }
                        else {
                            //当前时间还没到，暂时先不执行
                            //不能使用sleep,会错过新的任务，也无法释放锁。
                            locker.wait(task.getTime() - curTime);//解决“忙等”，时间没到却一直执行前面的判断
                        }
                    }//解锁
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
    }
}

4.线程池

线程池:把要使用的线程提前创建好。用完了也不要直接释放而是以备下次使用。就节省了创建/销毁线程的开销在这个使用的过程中，并没有真的频繁创建销毁，而只是从线程池里，取线程使用，用完了还给线程池.
这样虽然占用空间多了，但是减少了减少每次启动、销毁线程的损耗。

4.1 标准库中的线程池

使用 Executors.newFixedThreadPool(5) 能创建出固定包含 5 个线程的线程池.
返回值类型为 ExecutorService
通过 ExecutorService.submit 可以注册一个任务到线程池中.

ExecutorService pool = Executors.newFixedThreadPool(10);  
pool.submit(new Runnable() {  
	@Override  
	public void run() {  
	System.out.println("hello");  
	}  
});

Executors 创建线程池的几种方式 ：
（1）newFixedThreadPool: 创建固定线程数的线程池
（2）newCachedThreadPool: 创建线程数目动态增长的线程池.
（3）newSingleThreadExecutor: 创建只包含单个线程的线程池.
（4）newScheduledThreadPool: 设定 延迟时间后执行命令，或者定期执行命令. 是进阶版的 Timer.
Executors 本质上是 ThreadPoolExecutor 类的封装.

ThreadPoolExecutor 提供了更多的可选参数, 可以进一步细化线程池行为的设定.
在这里插入图片描述

  1. int corePoolSize - 核心线程数:一个线程池里，最少得有多少个线程.

标准库提供的线程池，持有的线程个数并非是一成不变的，会根据当前任务量，自适应线程个数(任务非常多，就多搞几个线程；任务比较少，就少搞几个线程)

  1. int maximumPoolSize - 最大线程数: 一个浅程地里最多能有多少个线程

  2. long keepAliveTime - 保持存活时间:即非核心线程最大的可空闲时间（超过时间就销毁）

  3. TimeUnit unit - 时间单位：s,min,ms,hour.…

  4. BlockingQueue < Runnable > workQueue - 任务队列：存放线程池的多个任务的队列（可以设置PriorityBlockingQueue,且使用Runnable来作为描述任务的主体）

  5. ThreadFactory threadFactory - 线程工厂 ： 通过这个工厂类，来创建线程对象(Thread对象) （工厂模式，也是一种常见的设计模式。通过专门的"工厂类”/"工厂对象"来创建指定的对象）

  6. RejectedExecutionHandler handler - 拒绝策略：上述参数中最重要的。

在线程池中，有一个阻塞队列。能够容纳的元素有上限的。当任务队列已经满了，如果继续往队列中添加任务，那么线程池会咋办。
在这里插入图片描述

（1）AbortPolicy：当任务队列已经满了，如果继续往队列中添加任务，新任务旧任务都不做了，直接抛出异常。
（2）CallerRunsPolicy：当任务队列已经满了，如果继续往队列中添加任务，新添加的任务由添加任务的线程来完成，任务队列还是执行原来的任务。
（3） DiscarduldestpoLlcy：当任务队列已经满了，如果继续往队列中添加任务，旧任务都不做了，直接开始完成新任务。
（4）DiscardPolicy: 当任务队列已经满了，如果继续往队列中添加任务，新任务都不做了，继续完成旧任务。

4.2 实现线程池

直接写一个固定线程数目的线程池（暂时不考虑线程的增加和减少）

（1)提供构造方法，指定创建多少个线程
（2)在构造方法中，把这些线程都创建好
（3)用一个阻塞队列，保存要执行的任务
（4)提供submit方法，可以添加新的任务。

class MyThreadPoolExecutor {
	private List<Thread> threadList = new ArrayList<>();
	private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);

	public MyThreadPoolExecutor(int n) {//创建n个线程
		for (int i = 0; i < n; i++) {
			Thread thread = new Thread(()->{//不断取出任务队列中的任务并执行
				while (true) {
					try {
						Runnable runnable = queue.take();
						runnable.run();
					}
					catch (InterruptedException e) {
						throw new RuntimeException(e);
					}
				}
			});

			thread.start();
			threadList.add(thread);
		}
	}
	public void submit(Runnable runnable) throws InterruptedException {
		queue.put(runnable);
	}
}

public static void main(String[] args) throws InterruptedException {
	MyThreadPoolExecutor executor = new MyThreadPoolExecutor(4);
	for (int i = 0; i < 1000; i++) {
		int n = i;
		executor.submit(new Runnable(){
			@Override
			public void run() {
				System.out.println("正在执行任务" + n + "当前线程为：" + Thread.currentThread().getName());
			}
			});
	}
}

一定要注意，多个线程之间的执行顺序是不确定的，某个线程取到了某个任务了，但是并非立即就执行，这个过程中另一个线程就插到前面了此处的这些线程，彼此之间都是等价的.
在这里插入图片描述

莲雾flops
关注
  • 17
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVAEE初阶第二节——多线程基础(中)
2301_79418684的博客
08-31 886
多线程基础(中) 1. 多线程带来的的风险-线程安全 (重点) 2. synchronized 关键字 3. volatile 关键字 4. wait 和 notify
JAVAEE初阶第二节——多线程基础(上)
2301_79418684的博客
08-30 737
计算机的工作原理 1. 认识线程（Thread） 2. Thread 类及常见方法 3. 线程的状态
JavaEE 初阶（3）—— 多线程1之理解线程
2301_80243321的博客
07-21 1010
线程是当下实现“并发编程”的主流方式，通过多线程，就可以充分利用好 多核CPU。
JavaEE 初阶（11）——多线程9之“阻塞队列”
2301_80243321的博客
07-29 1322
本篇主要是一些“阻塞队列”的相关知识，讲解了阻塞队列在“生产者消费者模型”中的应用
JavaEE 初阶（13）——多线程11之“定时器”
2301_80243321的博客
08-01 1327
本篇主要讲解了“定时器”，日常开发中非常重要，并进行了实现。其中涉及了一些线程安全问题，逻辑比较复杂，需要考虑的问题也很多
JavaEE 初阶（8）——多线程6之线程安全下--＞volatile
2301_80243321的博客
07-26 1235
本篇主要介绍了volatile关键字，其中也涉及到了“内存可见性”“编译器优化”等知识点
JavaEE 初阶（10）——多线程8之“单例模式”
2301_80243321的博客
07-28 924
本篇主要详细讲解了单例模式中“懒汉模式”与 “线程安全“ 相关的问题
JavaEE 初阶（6）——多线程4之线程状态+线程安全上
2301_80243321的博客
07-24 926
本篇讲解了线程状态，介绍了部分与线程安全相关的问题，包括线程不安全的原因，解决线程不安全的方法——使用关键字synchronized
JavaEE 初阶（7）——多线程5之线程安全中 --＞“死锁”
2301_80243321的博客
07-25 1596
本篇详细介绍了什么是“死锁”，以及“死锁”的产生场景 和 必要条件等 重要内容
【JavaEE初阶系列】——多线程案例三——定时器
2301_76278775的博客
04-08 821
MyTask类用于描述一个任务作为Timer的内部类).里面包含一个Runnable对象和一个time(毫秒时间戳)
【JavaEE初阶】多线程 _ 基础篇 _ 阻塞队列（案例二）
哎呀是小张啊 的博客
08-23 853
这篇博客主要介绍的是多线程的第二个案例 —— 阻塞队列，主要包含了 阻塞魔性的理论知识，以及 Java标准库 里面自带的阻塞队列的实现 和 自己手动去模拟一个阻塞队列的实现~~~~~~~~~~~~~~
【JavaEE初阶】多线程 _ 基础篇 _ 定时器（案例三）
哎呀是小张啊 的博客
08-25 625
这篇博客主要是介绍多线程的第三个案例 —— 定时器，主要的目地是 理解定时器内部的原理，更加熟练的使用锁、wait / notify 等方法，更加熟练的 理解线程安全问题~~~~~~~~~~~~~~~
每天40min，我们一起用70天稳扎稳打学完《JavaEE初阶》——4/70 第四天【多线程安全问题原因】【如何解决线程安全问题】【指令重排序问题（可以用单例模式的懒汉模式举例）】
蓝天it（让亿万孩子在蓝天下共享优质教育）
08-03 46
专注 效率 记忆预习 笔记 复习 做题欢迎观看我的博客，如有问题交流，欢迎评论区留言，一定尽快回复！（大家可以去看我的专栏，是所有文章的目录）文章字体风格：红色文字表示：重难点★✔蓝色文字表示：思路以及想法★✔转发！本系列通过70天学习完JavaEE初阶，我们不图快，只求稳扎稳打。由于我高三是在家自学的，经验告诉我，学习一定要长期积累，并且及时复习，由于现在课程知识在网络上非常多，大家不知道学习进度以及方向，会感到迷茫，为了稳扎稳打，稳定学习，所以我推出此系列。
每天40min，我们一起用70天稳扎稳打学完《JavaEE初阶》——5/70 第五天【synchronized】【volatile】
蓝天it（让亿万孩子在蓝天下共享优质教育）
08-03 145
专注 效率 记忆预习 笔记 复习 做题欢迎观看我的博客，如有问题交流，欢迎评论区留言，一定尽快回复！（大家可以去看我的专栏，是所有文章的目录）文章字体风格：红色文字表示：重难点★✔蓝色文字表示：思路以及想法★✔转发！本系列通过70天学习完JavaEE初阶，我们不图快，只求稳扎稳打。由于我高三是在家自学的，经验告诉我，学习一定要长期积累，并且及时复习，由于现在课程知识在网络上非常多，大家不知道学习进度以及方向，会感到迷茫，为了稳扎稳打，稳定学习，所以我推出此系列。
JAVAEE初阶第一节——计算机的工作原理
2301_79418684的博客
08-29 1059
计算机的工作原理 1. 计算机发展史 2. 冯诺依曼体系（Von Neumann Architecture） 3. CPU 4. 操作系统（Operating System）
《JavaEE进阶》----3.＜SpringBoot项目创建细节大全+打jar包运行＞
m0_73456341的博客
08-28 1212
本篇博客讲解了创建Spring Boot项目的各种方法及创建细节、还有项目中目录和代码的简单介绍、启动项目、换端口号、Web服务器简介、HTTP状态码、以及用Maven打jar包运行
《JavaEE进阶》----7.＜SpringMVC实践项目：【登录页面的验证】＞
最新发布
m0_73456341的博客
09-01 854
这篇文章详细的讲解了一个 简单的登录网页的前端代码和后端代码的构造 使用了JavaScript中的ajax来进行前后端的交互
《JavaEE进阶》----5.＜SpringMVC②剩余基本操作（Cookie&Session&Header&响应）＞
m0_73456341的博客
08-29 880
Cookie和Session简介。 Spring MVC的请求中 Cookie的设置和两种获取方式 Session的设置和三种获取方式。 3.响应 1.返回静态页面 2.返回数据 3.返回HTML片段 4.返回JSON 5.设置状态码 6.设置header
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值