java多线程总结学习-Queue、容器、单例模式

最新推荐文章于 2024-08-21 17:38:46 发布

原创最新推荐文章于 2024-08-21 17:38:46 发布 · 831 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #多线程 #单例模式 #并发类容器 #QUEUE

java 专栏收录该内容

15 篇文章

订阅专栏

本文深入探讨了Java多线程环境下的单例模式实现，包括静态内部类和双重检查实例化。接着，介绍了同步类容器与并发类容器如ConcurrentHashMap和Copy-On-Write策略。同时，详细讲解了并发队列的使用，如ConcurrentLinkedQueue、BlockingQueue的各种实现，特别提到了PriorityBlockingQueue在任务优先级分配中的应用，以及DelayQueue在模拟网吧上机时间管理中的场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、单例模式支持多线程

单例模式：常用的两种模式：饿汉模式懒汉模式，但这两种模式在多线程应用场景并不安全

为了适用于多线程，保障线程安全，用下面两种：double check instance、static inner class

（1）static inner class

package thread;

/**
 * 单例模式，保障线程安全
 * static inner class
 * 静态内部类形式
 */
public class SingleInner {

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

（2）double check instance

public class Singleton{
	//私有静态实例，防止被引用
	private static Singleton instance = null;

	//私有构造方法，防止被实例化
	private Singleton(){
	}

	private static synchronized void syncInit(){
		if(instance == null){
			instance = new Singleton();
		}
	}
	
	public static Singleton getInstance(){
		if(instance == null){
			syncInit();
		}
		return instance;	
	}
}

2、同步类容器、并发类容器

同步类：vector hashTable(底层自带synchronid修饰，实现了同步，但是影响并发效率)

并发类：Queue、concurrentMap、LinkedBlockingQueue、CopyOnWrite

（1）ConcurrentHashMap：

用段segment划分多个段，每个段相当于hashTable,有对应锁，最高支持16个段
每个线程来的时候，访问不同的段
作用：减少锁粒度，减少锁竞争
底层大量使用volatile关键字，实现共享变量

（2）Copy-On-Write(COW)

CopyOnWriteArrayList和CopyOnWriteArraySet
写时复制的容器、实现读写分离
当一个线程操作（增删改）容器时，不直接操作该容器，而是复制一个一模一样的容器进行操作，操作完成后，将原容器的指针指向复制的容器。
当有其他线程进行读时，直接读取原容器，实现读写相分离
应用场景：读多写少的时候

3、并发queue

ConcurentLinkedQueue:非阻塞的，性能高,高并发
BlockingQueue：阻塞的

ConcurentLinkedQueue:
先进先出，头是最先的，尾是最近的，不允许有null值
add() offer()加入元素，在ConcurentLinkedQueue里没区别
poll() peek() 取头元素，前者删除元素，后者不删

BlockingQueue：，阻塞的
1、ArrayBlockingQueue，基于数组、有界队列，阻塞的
2、LinkedBlockingQueue 无界队列，阻塞的
3、synchronousQueue:没有缓冲的队列，不能添加元素
4、priorityBlockingQueue:基于优先级的阻塞队列，传入队列的对象必须实现comparable接口不遵循先进先出
5、DelayQueue:元素必须实现delayed接口，元素必须到达延迟时间时，才会被取出

（1）ConcurentLinkedQueue

package queue;

import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * ConcurrentLinkedQueue非阻塞的，性能高,高并发
 * 先进先出，头是最先的，尾是最近的，不允许有null值
 * add() offer()加入元素，在ConcurentLinkedQueue里没区别
 * poll() peek() 取头元素，前者删除元素，后者不删
 */
public class UseConcurrentQueue {

	public static void main(String[] args) {
		ConcurrentLinkedQueue<String> q = new ConcurrentLinkedQueue<String>();
		
		q.add("a");
		q.add("b");
		q.add("c");
		q.add("d");
		q.offer("e");
		q.offer("f");
		
		System.out.println(q.size());
		System.out.println(q.poll());
		System.out.println(q.size());
		System.out.println(q.peek());
		System.out.println(q.size());
	}
}

（2）BlockingQueue（ArrayBlockingQueue、linkedBlockingQueue、SynchronousQueue）

package queue;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;

/**
 * BlockingQueue：阻塞的
 * ArrayBlockingQueue：基于数组的，有界的
 * linkedBlockingQueue：无界的，在初始化时，给定长度，则是有界的，不给定长度，则是无界的
 * SynchronousQueue：没有容量的队列，take()方法会进行阻塞，执行过take后，可以进行add,直接add会报错，因为没容量
 *
 */
public class UseBlockingQueue {
	public static void main(String[] args) throws Exception{
		//ArrayBlockingQueue
		ArrayBlockingQueue<String> aq = new ArrayBlockingQueue<String>(5);
		aq.add("a");
		aq.add("b");
		aq.put("c");
		aq.put("d");
		aq.offer("e");
		aq.offer("f");
		System.out.println("ArrayBlockingQueue："+aq);
		
		
		//linkedBlockingQueue
		LinkedBlockingQueue<String> lq = new LinkedBlockingQueue<>();
		lq.add("a");
		lq.add("b");
		lq.put("c");
		lq.put("d");
		lq.offer("e");
		lq.offer("f");
		System.out.println("LinkedBlockingQueue无界："+lq);
		
		LinkedBlockingQueue<String> lq2 = new LinkedBlockingQueue<>(4);
		lq2.add("a");
		lq2.add("b");
		lq2.put("c");
		lq2.put("d");
		lq2.offer("e");
		lq2.offer("f");
		System.out.println("LinkedBlockingQueue有界："+lq2);
		
		//synchronousQueue
		final SynchronousQueue<String> sq = new SynchronousQueue<>();
		//sq.add("a");		//会报错java.lang.IllegalStateException: Queue full
		Thread t1 = new Thread(new Runnable(){

			@Override
			public void run() {
				try {
					sq.take();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
			
		});
		t1.start();
		
		Thread t2 = new Thread(new Runnable(){

			@Override
			public void run() {
				sq.add("a");
				System.out.println("SynchronousQueue："+sq);
			}
			
		});
		t2.start();
	}
}

（3）PriorityBlockingQueue。模拟场景：当有任务时，会根据任务ID，按照优先级，进行释放

package queue;

import java.util.concurrent.PriorityBlockingQueue;

import queue.priority.Task;

/**
 * PriorityBlockingQueue：优先级队列
 * 队列里的元素必须继承comparable接口，并实现方法
 * 当对队列进行take操作是，队列会根据优先级排序（不遵循先进先出）
 * 
 */
public class UsePriorityBlockingQueue {
	
	public static void main(String[] args) throws Exception{
		
		PriorityBlockingQueue<Task> pq = new PriorityBlockingQueue<Task>();
		
		Task t1 = new Task();
		t1.setId(1);
		t1.setName("任务1");
		
		Task t2 = new Task();
		t2.setId(4);
		t2.setName("任务2");
		
		Task t3 = new Task();
		t3.setId(3);
		t3.setName("任务3");
		
		pq.add(t1);
		pq.add(t2);
		pq.add(t3);
		
		System.out.println("容器："+pq.toString());
		System.out.println(pq.take().getId());
		System.out.println("容器："+pq.toString());
		System.out.println(pq.take().getId());
		System.out.println(pq.take().getId());
	}
}

package queue.priority;

public class Task implements Comparable<Task>{
	private int id;
	private String name;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public int compareTo(Task o) {
		return this.id > o.id ? 1 : (this.id > o.id ? -1 : 0);
	}
	
	
	public String toString(){
		return this.id + "," + this.name;
	}
}

运行结果：

容器：[1,任务1, 4,任务2, 3,任务3]
1
容器：[3,任务3, 4,任务2]
3
4

（4）DelayQueue，模拟场景，网吧上机，到时间下机

package queue;

import java.util.concurrent.DelayQueue;

import queue.delay.Wangmin;

/**
 * DelayQueue：延迟队列
 * 元素必须实现delayed接口
 * 元素必须到达延迟时间时，才会被取出
 */
public class UseDelayQueue implements Runnable{

	DelayQueue<Wangmin> dq = new DelayQueue<Wangmin>();
	
	public void shangji(int id, String name, int money){
		Wangmin wm = new Wangmin(id,name,1000*money+System.currentTimeMillis());
		dq.add(wm);
		System.out.println("网民："+name+"开始上机，上机时间"+money+"秒");
	}
	
	public void xiaji(Wangmin wm){
		System.out.println("网民："+wm.getName()+"下机。。。");
	}
	
	@Override
	public void run() {
		while(true){
			try {
				Wangmin wm = dq.take();
				xiaji(wm);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		
		UseDelayQueue udq = new UseDelayQueue();
		Thread t = new Thread(udq);
		t.start();
		
		udq.shangji(1,"张三",1);
		udq.shangji(2,"李四",10);
		udq.shangji(3,"王五",5);
		
	}

}

package queue.delay;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * 网民
 * 实现了Delayed接口
 * 需要实现getDelay、compareTo方法
 */
public class Wangmin implements Delayed{
	private int id;
	private String name;
	private long endtime;
	private TimeUnit timeUnit = TimeUnit.SECONDS;//时间单位，秒
	
	//构造方法
	public Wangmin(int id, String name, long endtime){
		this.id=id;
		this.name = name;
		this.endtime = endtime;
	}

	@Override
	public int compareTo(Delayed delay) {
		Wangmin w = (Wangmin)delay;
		return this.getDelay(this.timeUnit) > w.getDelay(this.timeUnit) ? 1 : 0;
	}

	@Override
	public long getDelay(TimeUnit arg0) {
		return endtime - System.currentTimeMillis();
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public long getEndtime() {
		return endtime;
	}

	public void setEndtime(long endtime) {
		this.endtime = endtime;
	}
}

运行结果：

网民：张三开始上机，上机时间1秒
网民：李四开始上机，上机时间10秒
网民：王五开始上机，上机时间5秒
网民：张三下机。。。
网民：王五下机。。。
网民：李四下机。。。