强制线程到共享内存中读取数据,而不是从线程的工作空间的读取数据,从而可以可以使变量在多线程间可见
volatile无法保证原子性,volatile属于轻量级的同步性能比synchronized强很多(不加锁),但只能保证变脸在线程间的可见性,不能代替synzhronized的同步功能,netty框架大量使用了volatile关键字
static是保证唯一性,不保证一致性,多个实例共享一个变量
比如: private static int a;
也就是说如果多个对象实例共享一个a属性,当一个对象实例改变了a属性值其他实例也就改变了
volatile保证一致性,不保证唯一性,多个实例多个volatile变量
比如: private volatile int a;
当多个类对象实例每个对象中a是不一样的,当其中一个改变其他的是不会改变的,volatile的唯一性是在并发线程是多个线程间使用一个对象的a变量的一致性
不能保证原子性是比如用volatile修饰的变量在自增的操作中i++中分三步,第一步读取i值,第二部赋值,第三部放回内存
- 比如有一个i值为10在自增操作
- 有线程A与线程B两个线程
- 在线程A执行i++语句时会想从内存中获取i的值,就在这时线程B也执行i++语句,B也从内存中获取值,
- 然后线程A执行执行++操作,B也执行++操作,同时返回内存中是,其实只是+1
1 public class ThreadDemo09 implements Runnable {
2
3 private static volatile int sum = 0; 4 5 public static void add() { 6 System.out.println(Thread.currentThread().getName() + "循环前sum值" + sum); 7 for (int i = 0; i < 10000; i++) { 8 sum++; 9 } 10 System.out.println(Thread.currentThread().getName() + "循环后sum值" + sum); 11 } 12 13 @Override 14 public void run() { 15 add(); 16 } 17 18 public static void main(String[] args) { 19 ExecutorService es = Executors.newFixedThreadPool(10); 20 for (int i = 0; i < 10; i++) { 21 es.submit(new ThreadDemo09()); 22 } 23 es.shutdown(); 24 while (true) { 25 if (es.isTerminated()) { // 判断线程是否消亡 26 if (sum == 100000) { 27 System.out.println(sum + "=ok"); 28 } else { 29 System.out.println(sum + "=no"); 30 } 31 break; 32 } 33 } 34 } 35 }
使用AtomicInteger等原子类可以保证变量的原子性,但是不能保证成员方法的原子性Atomic类采用CAS这种非锁机制
1 private static AtomicInteger sum = new AtomicInteger(0);
2
3 public static void add() { 4 sum.addAndGet(1); 5 try { 6 Thread.sleep(1000); 7 } catch (InterruptedException e) { 8 e.printStackTrace(); 9 } 10 sum.addAndGet(9); 11 System.out.println(Thread.currentThread().getName() + "---> sum=" + sum); 12 } 13 14 public static void main(String[] args) { 15 ExecutorService es = Executors.newFixedThreadPool(10); 16 for (int i = 0; i < 10; i++) { 17 es.submit(new ThreadDemo10()); 18 } 19 es.shutdown(); 20 } 21 22 @Override 23 public void run() { 24 add(); 25 }
使用ThreadLocal维护变量时,ThreadLocal给每个使用该变量的线程一个变量副本,所以每一个线程都可以独立修改变量内容,但是不会影响其他线程使用该变量
final static ThreadLocal<Integer> local = new ThreadLocal<Integer>();
public static void main(String[] args) throws InterruptedException { new Thread(() -> { local.set(100); System.out.println(Thread.currentThread().getName() + " localSet=" + local.get()); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " localGet=" + local.get()); }, "t1").start(); Thread.sleep(1000); new Thread(() -> { Integer integer = local.get(); System.out.println(Thread.currentThread().getName() + " localSet=" + integer); local.set(200); System.out.println(Thread.currentThread().getName() + " localGet=" + local.get()); }, "t2").start(); }
Vector,HashTable都是古老的并发容器,都是使用Collections.synchronizedXXX()工厂方法创建的,并发状态下只能有一个线程访问对象,性能极低,
collections可以将不是线程安全的集合变为线程安全的,就是在collections工具类中有每个集合的静态同步类,比如list,在collection有一个synchronizedList的静态内部类,该类实现了list接口同时继承synchronizedCollections类在这个,但是本质上还是使用的list的方法,只是在方法外包裹了一层synchronized锁
public static void main(String[] args) {
// final List<String> list = new ArrayList<>();
List<String> list = Collections.synchronizedList(new ArrayList<String>()); ExecutorService es = Executors.newFixedThreadPool(100); for (int i = 0; i < 10000; i++) { es.execute(()->{ list.add("5"); }); } es.shutdown(); while(true) { if(es.isTerminated()) { if(list.size() >= 10000) { System.out.println("线程安全"); }else { System.out.println("线程不安全"); } System.out.println(list.size()); break; } } }
JDK5.0以后有很多并发类比如concurrentMap属于并发类容器,vector与hashtable属于同步类容器,是将整个容器加锁,而concurrentMap是将需要操作的一个区域加锁,这样性能就大大的提高了
ConcurrentHashMap代替HashMap,HashTable
ConcurrentSkipListMap 代替了 TreeMap
ConcurrentHashMap将hash表分为16个segment(段),每个segment单独进行锁控制,从而减小了锁的粒度,提升了性能
ConcurrentHashMap
ConcurrentHashMap替换了 HashMap 与 HashTable
HashMap是线程不安全的,性能高.
HashTable是线程安全的,性能低
ConcurrentHashMap 线程安全,性能比HashTable高
性能比较
HashMap > ConcurrentHashMap > HashTable
public static void TestMap() {
/**
* HashTable是同步类容器,ConcurrentHashMap并发类容器 同步类容器将整个容器加锁,性能低,
* 并发类容器是将操作那个位置,给那个位置加锁.
*/
// 性能最高,不安全
// HashMap<String,Integer> map = new HashMap<String, Integer>();
// 在安全的情况下,性能高
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>(); // 线程安全性能低 // Hashtable<String, Integer> map = new Hashtable<String, Integer>(); for (int i = 0; i < 10; i++) { new Thread(() -> { long start = System.currentTimeMillis(); for (int j = 0; j < 1000000; j++) { map.put(("a" + j), j); } long end = System.currentTimeMillis(); System.out.println(Thread.currentThread().getName() + "---------)" + (end - start)); }, "T" + i).start(); } }
ConcurrentHashMap新方法
public static void TestMap1() {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>(); map.put("a", 1); map.put("b", 1); map.put("c", 1); //key存在则替换 map.put("a", 2); //key存在则不替换 map.putIfAbsent("b", 2);//putIfAbsent方法存在不替换,但是 System.out.println(map.toString()); }
ConcurrentSkipListMap'
ConcurrentSkipListMap替换与storedMap对比
public static void TestMap1() {
//性能低,线程安全
// SortedMap<String, Integer> map = Collections.synchronizedSortedMap(new TreeMap<String, Integer>());
//线程安全,性能高
ConcurrentSkipListMap<String,Integer> map = new ConcurrentSkipListMap<String,Integer>(); //线程不安全,性能高 // final SortedMap<String, Integer> map = new TreeMap<String, Integer>(); for (int i = 0; i < 10; i++) { new Thread(() -> { long start = System.currentTimeMillis(); for (int j = 0; j < 100000; j++) { map.put("a" + j, j); } long end = System.currentTimeMillis(); System.out.println(Thread.currentThread().getName() + "--->" + (end - start)); }, "T" + i).start(); } }
ConcurrentSkipListMaP新方法
public static void TestSkipListMap1() {
ConcurrentSkipListMap<String,Integer> map = new ConcurrentSkipListMap<String,Integer>(); map.put("a", 1); map.put("b1", 1); map.put("c", 1); //key存在则替换 map.put("a", 2); //key存在则不替换 map.putIfAbsent("b", 2); //并进行了排序 System.out.println(map.toString()); }
COW并发类容器
Copry on Write 容纳简称COW;
写时复制容器,向容器中添加元素时,先将容器进行Copy出一个新容器,然后将元素添加到新容器中,再将原容器中的引用指向新容器,并发读的时候不需要锁定容器,因为原容器没有变化,使用读写分离的思想,由于每次更新数据都会创建一个新容器,所以数据量较大并且频繁更新则对内存消耗很高,建议在高并发读的场景下使用
CopyOnWriteArraySet是基于CopyOnWriteArrayLiet实现的,其唯一的不同是add时调用的时候,CopyOnWriterArrayList的addIfAbsent方法同样采用锁保护,并创建一个新的大小+1的Object数组,遍历当前数组,如果Object中有当前元素,直接返回不添加,如果没有这个元素就添加到末尾,并返回,但CopyOnWriteArraySet 需要每次add都需要循环遍历,所以效率没有CopyOnWriteArrayList高
public static void TestCOWArray() {
CopyOnWriteArrayList<String> cowArray = new CopyOnWriteArrayList<String>();
cowArray.add("1");
cowArray.add("2");
cowArray.add("3");
cowArray.add("4");
cowArray.add("4");
// 假如存在则不添加,不存在添加
cowArray.addIfAbsent("2");
cowArray.addIfAbsent("5");
System.out.println(cowArray.toString());
}
//源码
public boolean addIfAbsent(E e) {
Object[] snapshot = getArray(); //获取当前数组
return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
addIfAbsent(e, snapshot);
}
/**
* A version of addIfAbsent using the strong hint that given
* recent snapshot does not contain e.
*/
//添加一个数据需要查询数组是否有要添加的数据,有则不添加,没有则添加到末尾
private boolean addIfAbsent(E e, Object[] snapshot) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] current = getArray();
int len = current.length;
if (snapshot != current) {
// Optimize for lost race to another addXXX operation
int common = Math.min(snapshot.length, len);
for (int i = 0; i < common; i++)
if (current[i] != snapshot[i] && eq(e, current[i]))
return false;
if (indexOf(e, current, common, len) >= 0)
return false;
}
Object[] newElements = Arrays.copyOf(current, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
public static void TestCOWSet() {
CopyOnWriteArraySet<String> set = new CopyOnWriteArraySet<String>();
set.add("1");
set.add("2");
set.add("3");
set.add("4");
System.out.println(set);
set.add("4");
// 假如存在则不添加,不存在添加
set.add("5");
System.out.println(set);
}
//CopyOnWriteArraySet源码
//CopyOnWriteArraySet 中使用的就是CopyOnWriteArrayList
public class CopyOnWriteArraySet<E> extends AbstractSet<E>
implements java.io.Serializable {
private static final long serialVersionUID = 5457747651344034263L;
private final CopyOnWriteArrayList<E> al;
//add方法时用的al的addIfAbsent方法每次添加都需要遍历
public boolean add(E e) {
return al.addIfAbsent(e);
}
