1. 单例模式
- 单例模式是一种对象创建模式，用于产生一个对象的具体实例，确保系统中一个类只产生一个实例。有两大好处：
- 对于频繁使用的对象，可以省略new操作花费的时间，对于一些重量级对象，是一笔可观的系统开销。
- 减轻GC压力，缩短GC停顿时间。
//内存开销大，并发不安全
class Single1{
private static final Single1 SINGLE1 = new Single1();
private Single1() {
}
public static Single1 getInstance() {
return SINGLE1;
}
}
//并发安全，有锁性能开销大，内存开销小
class Single2{
private static Single4 single2 = null;
private Single2() {
}
public static synchronized Single2 getInstance() {
if(single2 == null) {
single2 = new Single4();
}
return single2;
}
}
//丑陋、复杂，低版本jdk不适用
class Single3{
private static volatile Single3 single3;
private Single3() {
}
public static Single3 getInstance() {
if(single3 == null) {
synchronized(Single3.class) {
if(single3 == null) {
single3 = new Single3();
}
}
}
return single3;
}
}
//并发安全，无锁性能高，内存开销小，巧妙利用虚拟机类加载机制
class Single4{
private Single4() {
}
private static class Inner{
private static final Single4 SINGLE4 = new Single3();
}
public static Single4 getInstance() {
return Inner.SINGLE4;
}
}
2. 不变模式
- 加锁操作有一定的性能损耗。
- 不变模式：天生多线程友好的。一旦对象被创建，则它的内部状态将永远不会发生改变。没有任何一个线程可以修改其内部状态和数据，同时其内部状态也不会发生改变。
- 只读属性：只读属性不会被其他修改，但是自身有可能变化，比如对象的存活时间会随着时间推移变化。
- 不变模式的主要使用场景需要满足两个条件：
- 当对象创建后，其内部状态和数据不再发生任何变化。
- 对象需要被共享，被多线程频繁访问。
【如何实现不变模式】：
- 去除setter和其他所有修改自身属性的方法。
- 将所有属性设为私有，并用final标记，确保其不可修改。
- 确保没有子类可以重载修改它的行为。
- 有一个可以创建完整对象的构造函数。
//final 起关键作用
public final class Product {
private final String no;
private final String name;
private final double price;
public Product(String no, String name, double price) {
super();
this.no = no;
this.name = name;
this.price = price;
}
public String getNo() {
return no;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
}
主要不变模式：
java.lang.String
java.lang.Boolean
java.lang.Byte
java.lang.Character
java.lang.Double
java.lang.Float
java.lang.Integer
java.lang.Long
java.lang.Short
3. 生产者-消费者模式
- 生产者-消费者模式提供了多线程间协作的良好解决方案。生产者负责提交用户请求，消费者负责处理任务，两者通过共享内存缓冲区进行通信。
- 内存缓冲区避免了生产者和消费者的直接通信，从而将生产者和消费者解耦。同时允许生产者和消费者在执行速度上存在时间差。
BlockingQueue实现生产者和消费者是一个不错的选择，但是BlockingQueue并不是一个高性能的实现，它完全使用锁和阻塞等待来实现线程间的同步。在高并发场合，它的性能不是特别的优越。可以用无锁的Disruptor实现。Disruptor使用无锁的方式实现了一个环形队列，生产者和消费者都是用CAS操作来处理环形队列中的数据。
4. Future模式
- 核心思想是异步调用，当我们需要调用一个函数方法时，如果这个函数执行很慢而我们又不是立刻需要结果，可以让被调者立刻返回，让他在后台慢慢处理这个请求，对调用者来说，可以先处理一些其他任务，在真正需要数据的场合再去尝试获得需要的数据。
public interface Data {
public String getResult();
}
//FutrureData是RealData的虚拟实现，可以很快被构造并返回。如果数据没准备好，那么程序会阻塞。
public class FutureData implements Data {
protected RealData realData = null;
protected boolean isReady = false;
public synchronized void setRealData(RealData realData) {
if(isReady) {
return;
}
this.realData = realData;
isReady = true;
notifyAll();
}
@Override
public synchronized String getResult() {
while(!isReady) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return realData.result;
}
}
public class RealData implements Data{
protected final String result;
public RealData(String para) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 10; i++) {
sb.append(para);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
result = sb.toString();
}
@Override
public String getResult() {
return result;
}
}
public class Client {
public Data request(final String queryStr) {
final FutureData futureData = new FutureData();
new Thread() {
public void run() {
RealData realData = new RealData(queryStr);
futureData.setRealData(realData);
}
}.start();
return futureData;
}
}
public class Main {
public static void main(String[] args) {
Client client = new Client();
Data data = client.request("name");
System.out.println("请求完毕");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("真实数据"+data.getResult());
}
}
5. JDK的Future
image.png
public interface Callable<V> {
V call() throws Exception;
}
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}
public class CallableDemo implements Callable<Integer> {
private int sum;
@Override
public Integer call() throws Exception {
System.out.println("Callable子线程开始计算啦！");
Thread.sleep(2000);
for(int i=0 ;i<5000;i++){
sum=sum+i;
}
System.out.println("Callable子线程计算结束！");
return sum;
}
}
ExecutorService es = Executors.newSingleThreadExecutor();
//创建Callable对象任务
CallableDemo calTask=new CallableDemo();
//提交任务并获取执行结果
Future<Integer> future =es.submit(calTask);
//关闭线程池
es.shutdown();
ExecutorService es = Executors.newSingleThreadExecutor();
//创建Callable对象任务
CallableDemo calTask=new CallableDemo();
//创建FutureTask
FutureTask<Integer> futureTask=new FutureTask<>(calTask);
//执行任务
es.submit(futureTask);
//关闭线程池
es.shutdown();
