目录:
1.线程安全单例模式的几种实现方式
2.同步容器
3.并发容器
一、线程安全单例模式的几种实现方式
1.饿汉式（不使用同步锁，典型的用空间换时间）
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();
}
}
}
运行结果：
当我们改用并发容器ConcurrentLinkedQueue时，我们调用poll方法售票直至票数为0时，字符串s会变为null，所以在接下来的if判断后会跳出
当我们在此例中使用了并发容器时，就具有高的效率同时也不会出现问题
四、其他常用同步容器
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