Java线程总结（二）

创建模式之单例模式

单例模式：只有一个实例，并且它自己负责创建自己的对象（在内存中有且只有一个对象），这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

懒汉式

实例在用到的时候才去创建，用的时候才去检查有没有实例，如果有则返回，没有则去新建。
线程不安全，要对getInstance方法进行改造，才能保证懒汉式单例的线程安全。
1）不改造getInstance方法，此时线程不安全，代码如下：

public class SingletonA {
	
	/**
	 * 懒汉式
	 */
	
	private static SingletonA instance;

	/**
	 * 构造方法
	 */

	private SingletonA() {

	}

	public   static SingletonA getInstance() {
		if (instance == null) {
			instance = new SingletonA();
		}
		return instance;
	}
}

2）为保证线程安全，加同步锁 Synchronized :
创建代码：

public class SingletonA {
	
	/**
	 * 懒汉式
	 */
	
	private static SingletonA instance;

	/**
	 * 构造方法
	 */

	private SingletonA() {

	}

	public  synchronized static SingletonA getInstance() {
		if (instance == null) {
			instance = new SingletonA();
		}
		return instance;
	}
}

测试代码：

public class SIngletonATest {

	public static void main(String[] args) {
		Thread a1 = new Thread(new SingletonThread());
		Thread a2 = new Thread(new SingletonThread());
		Thread a3 = new Thread(new SingletonThread());
		Thread a4 = new Thread(new SingletonThread());
		Thread a5 = new Thread(new SingletonThread());
		Thread a6 = new Thread(new SingletonThread());

		a1.start();
		a2.start();
		a3.start();
		a4.start();
		a5.start();
		a6.start();
	}

	static class SingletonThread implements Runnable {
		@Override
		public void run() {
			for (int i = 0; i <= 9; i++) {
				SingletonA a = SingletonA.getInstance();
				System.out.println(a.hashCode());
				try {
					Thread.sleep(190);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

3）用可重入锁实现线程安全：

import java.util.concurrent.locks.ReentrantLock;

public class SingletonA {

	/**
	 * 懒汉式
	 */

	private static SingletonA instance;

	/**
	 * 构造方法
	 */

	private SingletonA() {

	}

	public static SingletonA getInstance() {
		final ReentrantLock lock = new ReentrantLock(); // 创建
		lock.lock();
		try {
		if (instance == null) {
				instance = new SingletonA();
		}
		} finally {
			lock.unlock();
		}
		return instance;
	}
}

饿汉式

在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是天生的线程安全。
创建代码：

public class SingletonB {

	/**
	 * 饿汉式
	 */

	private static SingletonB instance = new SingletonB();

	private SingletonB() {

	}

	public static SingletonB getInstance() {
		return instance;
	}
}

测试代码：

public class SIngletonBTest {

	public static void main(String[] args) {
		Thread a1 = new Thread(new SingletonBThread());
		Thread a2 = new Thread(new SingletonBThread());
		Thread a3 = new Thread(new SingletonBThread());
		Thread a4 = new Thread(new SingletonBThread());
		Thread a5 = new Thread(new SingletonBThread());
		Thread a6 = new Thread(new SingletonBThread());

		a1.start();
		a2.start();
		a3.start();
		a4.start();
		a5.start();
		a6.start();
	}

	static class SingletonBThread implements Runnable {
		@Override
		public void run() {
			for (int i = 0; i <= 9; i++) {
				SingletonB a = SingletonB.getInstance();
				System.out.println(a.hashCode());
				try {
					Thread.sleep(190);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

枚举法

代码简介，自动支持序列化机制，绝对防止多次实例化
创建代码：

public enum SingletonC {
	INSTANCE;
}

测试代码：

public class SIngletonCTest {

	/**
	 * 枚举法
	 * 
	 * @param args
	 */

	public static void main(String[] args) {
		Thread a1 = new Thread(new SingletonCThread());
		Thread a2 = new Thread(new SingletonCThread());
		Thread a3 = new Thread(new SingletonCThread());
		Thread a4 = new Thread(new SingletonCThread());
		Thread a5 = new Thread(new SingletonCThread());
		Thread a6 = new Thread(new SingletonCThread());

		a1.start();
		a2.start();
		a3.start();
		a4.start();
		a5.start();
		a6.start();
	}

	static class SingletonCThread implements Runnable {
		@Override
		public void run() {
			for (int i = 0; i <= 9; i++) {
				SingletonC a = SingletonC.INSTANCE;
				System.out.println(a.hashCode());
				try {
					Thread.sleep(190);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

***模式说明：***一般情况因为懒汉式的线程不安全，不推荐使用；更多的使用饿汉式，其他的则根据具体情况而定。

生命周期-阻塞：wait()方法

wait()方法：
1）和sleep()方法一样，通过传入“睡眠时间”作为参数，时间到了就"醒了"。
2）不传入时间，进行“无限期”的等待，只能通过notify()方法进行唤醒。
3）释放同步锁，使得其他的线程可以使用同步控制块或者方法。

生产者&消费者模式实例

在线程开发中，生产者就是生产数据的线程，消费者就是消费数据的线程。
在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。
如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。
为了解决这个问题于是引入了生产者和消费者模式。
1）创建商品类：

public class C0ffee {
	private static volatile int id;// 商品的id
	private String name; // 商品名字
	private static AtomicInteger ato = new AtomicInteger();// 做累加确保唯一性

	public C0ffee(String name) {
		id = ato.incrementAndGet();
		this.name = name;
	}

	public static int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "C0ffee [name=" + name + "]";
	}

}

2）生产和消费商品类：

import java.util.Deque;
import java.util.LinkedList;

public class CoffeeShop {
	private Deque<C0ffee> pool = new LinkedList<>();
	private final int MAX_SIZE = 15; // 定义最大容量

	public synchronized void produce() { // 生产者 -----同步锁确保线程安全
		while (pool.size() >= MAX_SIZE) {

			System.out.println("coffee满了，生产者等待消费者进行消费>>>");
			try {
				wait(); // 使用wait()阻塞方法
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		C0ffee h = new C0ffee("香草coffee");
		pool.offer(h);
		System.out.println("生产者生产coffee" + h.getName() + "还剩下coffee：" + pool.size());
		System.out.println("唤醒消费者消费coffee");
		notifyAll(); // 唤醒阻塞
	}

	public synchronized void consume() { // 消费者 -----同步锁确保线程安全
		while (pool.isEmpty()) {

			System.out.println("coffee没有了，消费者等待生产者进行生产>>>");
			try {
				wait(); // 使用wait()阻塞方法
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		C0ffee h = pool.poll();
		System.out.println("消费一杯coffee" + h.getName() + "还剩下coffee：" + pool.size());
		System.out.println("唤醒生产者进行生产");
		notifyAll(); // 唤醒阻塞
	}
}

3）创建生产者线程：

public class ProduceThread extends Thread {
	private CoffeeShop cos;

	public ProduceThread(CoffeeShop cos) {

		this.cos = cos;
	}

	@Override
	public void run() {
		while (true) {
			cos.produce(); // 调用生产商品方法
			try {
				sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

4）创建消费者线程：

public class ConsumeThread extends Thread {
	private CoffeeShop cos;

	public ConsumeThread(CoffeeShop cos) {

		this.cos = cos;
	}

	@Override
	public void run() {
		while (true) {
			cos.consume(); // 调用消费商品方法
			try {
				sleep(350);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

5）测试：

public class PACtest {

	public static void main(String[] args) {
		CoffeeShop cos = new CoffeeShop();

		Thread p1 = new ProduceThread(cos); // 创建四个生产者
		Thread p2 = new ProduceThread(cos);
		Thread p3 = new ProduceThread(cos);
		Thread p4 = new ProduceThread(cos);

		Thread c1 = new ConsumeThread(cos); // 创建5个消费者
		Thread c2 = new ConsumeThread(cos);
		Thread c3 = new ConsumeThread(cos);
		Thread c4 = new ConsumeThread(cos);
		Thread c5 = new ConsumeThread(cos);

		p1.start();
		p2.start();
		p3.start();
		p4.start();

		c1.start();
		c2.start();
		c3.start();
		c4.start();
		c5.start();

	}

}

部分结果展示(因为生产者与消费者线程用的死循环，生产与消费过程将永久执行下去)：

线程池

线程的创建和销毁都需要映射到操作系统，故付出的代价很高。为了避免频繁创建，销毁线程以及方便线程管理的需要，线程池应用而生。

线程池的优点

1）降低资源销毁：重复利用线程池中已经存在的线程，减少了线程的创建和消亡造成的性能开销。
2）提高响应速度：当任务到达时，任务可以不需要等到线程创建就能执行。
3）防止服务器过载：形成内存溢出，或者CPU耗尽。
4）提高线程的可管理性：线程是稀缺资源，若无限的创建线程，不仅会消耗资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

拒绝策略

当线程池workQueue已满且无法再创建新的线程池时，就要拒绝后续任务，拒绝策略实现了 RejectedExecutionHandler 接口。

功能线程池

1.CachedThreadPool

缓存池线程，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则创建新线程。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewCacheThreadPoolDemo {

	public static void main(String[] args) {

		ExecutorService pool = Executors.newCachedThreadPool();

		for (int i = 0; i <= 6; i++) {
			pool.execute(() -> {
				for (int j = 0; j <= 9; j++) {
					System.out.println(Thread.currentThread().getName() + ">>>" + j);
				}
			});
		}
	}
}

2.NewSingleThreadPool

单线程池线程。线程池中心只有一个核心线程，线程执行完任务立即回收，只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewSingleThreadPoolDemo {

	public static void main(String[] args) {

		ExecutorService pool = Executors.newSingleThreadExecutor();

		for (int i = 0; i <= 9; i++) {
			pool.execute(() -> {
				for (int j = 0; j <= 9; j++) {
					System.out.println(Thread.currentThread().getName() + ">>>" + j);
				}
			});
		}
	}

}

3.NewFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewFixedThreadPoolDemo {

	public static void main(String[] args) {

		ExecutorService pool = Executors.newFixedThreadPool(6);

		for (int i = 0; i <= 9; i++) {
			pool.execute(() -> {
				for (int j = 0; j <= 9; j++) {
					System.out.println(Thread.currentThread().getName() + ">>>" + j);
				}
			});
		}
	}

}

4.NewScheduleThreadPool

创建一个定长线程池（普通线程数量无线），适用于定时及周期性任务执行

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class NewScheduleThreadPoolDemo {

	public static void main(String[] args) {
		
		ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
		
		pool.scheduleAtFixedRate(()->{
			System.out.println(new Date());
		}, 0, 1, TimeUnit.SECONDS);
	}

}