public class Singleton1 { private static Singleton1 mySingleton = new Singleton1(); private Singleton1(){ System.out.println("single"); } public static Singleton1 getSingle(){ return mySingleton; } public static void main(String[] args) { Thread[] ths = new Thread[200]; for(int i=0; i<ths.length; i++) { ths[i] = new Thread(()->{ Singleton1.getSingle(); }); } Arrays.asList(ths).forEach(o->o.start()); } }
运行结果：
2.懒汉式（使用同步锁，延时加载，典型的时间换空间）
public class Singleton2 { private static Singleton2 mySingleton; private Singleton2 (){ System.out.println("single"); } public static synchronized Singleton2 getSingle(){ //对获取实例的方法进行同步 if (mySingleton == null) mySingleton = new Singleton2(); return mySingleton; } public static void main(String[] args) { Thread[] ths = new Thread[200]; for(int i=0; i<ths.length; i++) { ths[i] = new Thread(()->{ Singleton2.getSingle(); }); } Arrays.asList(ths).forEach(o->o.start()); } }
运行结果：
3.双重同步锁（缩小粒度，双重检查
public class Singleton3 { private volatile static Singleton3 mySingleton; private Singleton3 (){ System.out.println("single"); } public static Singleton3 getSingle(){ //对获取实例的方法进行同步 if (mySingleton == null){ synchronized(Singleton3.class){ if (mySingleton == null) mySingleton = new Singleton3(); } } return mySingleton; } public static void main(String[] args) { Thread[] ths = new Thread[200]; for(int i=0; i<ths.length; i++) { ths[i] = new Thread(()->{ Singleton3.getSingle(); }); } Arrays.asList(ths).forEach(o->o.start()); } }
运行结果：
为mySingleton加上volatile关键字，以确保能先行发生关系（happens-before relationship），使所有的写操作都发生于读操作之前，避免出现在另一个线程中看到一个初始化一半的mySingleton的情况，同时双重同步锁的效率也很高
4.使用内部类的单例模式（既不用加锁，也能实现懒加载）
public class Singleton4 { private Singleton4() { System.out.println("single"); } private static class Inner { private static Singleton4 mySingleton = new Singleton4(); } public static Singleton4 getSingle() { return Inner.mySingleton; } public static void main(String[] args) { Thread[] ths = new Thread[200]; for(int i=0; i<ths.length; i++) { ths[i] = new Thread(()->{ Singleton4.getSingle(); }); } Arrays.asList(ths).forEach(o->o.start()); } }
运行结果：
二、同步容器1.vector、stack、hashtable等，保证了方法的原子性
2.小例子程序演示同步容器
/** * 有N张火车票，每张票都有一个编号 * 同时有10个窗口对外售票 * 请写一个模拟程序 * * 分析下面的程序可能会产生哪些问题？ * 重复销售？超量销售？ * */ package yxxy.c_024; import Java.util.ArrayList; import java.util.List; public class TicketSeller1 { static List<String> tickets = new ArrayList<>(); static { for(int i=0; i<10000; i++) tickets.add("票编号：" + i); } public static void main(String[] args) { for(int i=0; i<10; i++) { new Thread(()->{ while(tickets.size() > 0) { System.out.println("销售了--" + tickets.remove(0)); } }).start(); } } }
运行结果：
出现了越界情况，说明发生了超量销售与重��销售的情况
下面使用同步容器，以vector为例再做一遍售票操作
/** * 有N张火车票，每张票都有一个编号 * 同时有10个窗口对外售票 * 请写一个模拟程序 * * 分析下面的程序可能会产生哪些问题？ * * 使用Vector或者Collections.synchronizedXXX * 分析一下，这样能解决问题吗？ * */ package yxxy.c_024; import java.util.Vector; import java.util.concurrent.TimeUnit; public class TicketSeller2 { static Vector<String> tickets = new Vector<>(); static { for(int i=0; i<1000; i++) tickets.add("票 编号：" + i); } public static void main(String[] args) { for(int i=0; i<10; i++) { new Thread(()->{ while(tickets.size() > 0) { /* try { TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }*/ System.out.println("销售了--" + tickets.remove(0)); } }).start(); } } }
运行结果：
...
从运行结果来看，同步容器似乎已经达到了我们想要的目的，但其中还有一些问题
当我们使用了同步容器时，虽然容器的方法是具有原子性的，但当判断与操作分离时，中间的部分还是可能会被其他线程所打断，下面我们模拟一下判断与remove之间有其他的逻辑
/** * 有N张火车票，每张票都有一个编号 * 同时有10个窗口对外售票 * 请写一个模拟程序 * * 分析下面的程序可能会产生哪些问题？ * * 使用Vector或者Collections.synchronizedXXX * 分析一下，这样能解决问题吗？ * */ package yxxy.c_024; import java.util.Vector; import java.util.concurrent.TimeUnit; public class TicketSeller2 { static Vector<String> tickets = new Vector<>(); static { for(int i=0; i<1000; i++) tickets.add("票 编号：" + i); } public static void main(String[] args) { for(int i=0; i<10; i++) { new Thread(()->{ while(tickets.size() > 0) { try { TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("销售了--" + tickets.remove(0)); } }).start(); } } }
运行结果：
我们看到程序出现了错误，所以虽然同步容器保证了方法的原子性，但可能会发生判断与操作分离，整体操作不具备原子性
三、并发容器1.并发容器支持多线程
ConcurrentSkipListMap跳表结构，他是排好序的容器执行插入操作较快
ConcurrentHashMap将容器分成了16段，每次执行插入操作的时候只执行其中的一段，而HashTable为锁定一整段
ConcurrentLinkedQueue无界队列，内存耗不完的情况下可以一直加（offer，add），拿（poll拿出来删掉，peek拿出来不删）
BolckingQueue阻塞式队列，加（put如果满了就会等待），拿（take如果空了就会等待）
几个特殊的阻塞式队列：
1）TransferQueue转移队列，相较于其他队列，多了一个transfer方法生产者将任务直接发给消费者，不进入结束队列，在transfer找不到消费者情形下阻塞，实时处理用的较多，队列还有一定容量
2）DelayQueue计时任务队列
3）synchronusQueue同步队列，特殊的transferQueue，没有容量的队列，不能调用add方法，只能调用put方法阻塞等待消费者消费，生产者生产的任务直接给消费者消费
还是之前的售票程序，现在改用并发容器以ConcurrentLinkedQueue来重新实验一遍
/** * 有N张火车票，每张票都有一个编号 * 同时有10个窗口对外售票 * 请写一个模拟程序 * * 使用ConcurrentQueue提高并发性 */ package yxxy.c_024; import java.util.Queue; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.TimeUnit; public class TicketSeller4 { static Queue<String> tickets = new ConcurrentLinkedQueue<>(); static { for(int i=0; i<1000; i++) tickets.add("票 编号：" + i); } public static void main(String[] args) { for(int i=0; i<10; i++) { new Thread(()->{ while(true) { String s = tickets.poll(); if(s == null) break; else System.out.println("销售了--" + s); } }).start(); } } }
运行结果：
当我们在此例中使用了并发容器时，就具有高的效率同时也不会出现问题
四、其他常用同步容器1.Collocations.synchronizedXXX()将未加锁的容器加锁，在并发度不高的情况下可以使用此方法，在并发度较高且需排序的情况下使用concurrentSkipListMap
2.CopyOnWriteList写时复制链接表，在读取时不加锁，因此读取的时候效率高，但写的效率特别低，应用场景：在需要大量读取少量写入时使用
五、总结1.对于map/set的使用
无线程安全要求：hashmap、treemap、linkedhashmap
并发度低： hashtable、Collections.synchronizedXXX()
并发度高： concurrentHashMap、concurrentSkipListMap
2.list
无线程安全要求：ArrayList、LinkedList
并发度低： Collections.synchronizedXXX()
并发度高： Queue
concurrentLinkedQueue
BlockingQueue
LinkedBQ
ArrayBQ
TransferQueue
synchronusQueue
DelayQueue