一、并发编程
1 synchronized
同步修饰关键字
- (1) 修饰非静态方法（对象级）
- (2) 修饰静态方法（类级）
- (3) 方法块：
- synchronized(this){} (对象级)
- synchronized(Class){} (类级)
- synchronized(对象级){} (类级)
2 volatile
修饰关键字，使被修饰的变量在多线程中可见，能够使被修饰的变量每次使用的都是那一瞬间的最新值。
在java jdk1.5之后的版本中，为了优化多线程的性能，jdk会为每一个单线程创建一个单独的内存区，然后从主线程中将该线程所需要的变量的副本拷贝到这个单独的内存中，然后运行时获取数据均是从这个单独的内存中获取。所以对于多线程来说，不同线程对变量的读取只是读取自己的内存区创建的那一时刻从主内存中拷贝的变量的值。而volatile修饰的变量，会使线程每次读取该变量的时候都会从主内存中获取该变量的最新值，但是却只能保证瞬间数据最新，并不能保证同步。
3 AtomicInteger，AtomicLong等
该对象被称为一个Atomic单元，能够保证对该对象的一次操作的原子性，如果可能需要对该对象进行两次或两次以上，或对两个以及两个以上的Atomic对象进行操作，必须要在该方法上增加synchronize来保证该操作部分被当成是一个Atomic单元。
（1）ThreadLocal
ThreadLocal能够对所有线程可见，但是所有线程的ThreadLocal对象都是线程独立的，相互之间没有任何影响
4 多线程之间的通信
（1）wait与notify
java中使用wait notify方法来实现线程中的通信。这两个方法是Object类的方法，也就是说java中以及默认为所有对象提供这两个方法。
使用时有以下两点要注意
- ① wait与notify必须配合synchronized关键字一起使用
- ② wait方法释放锁，notify方法不释放锁，也就是说只有当调用notify的方法完全执行完了，才会释放锁，所以并不是调用notify之后，wait方法就会立刻会被唤醒。
（2）CountDownLatch
如果需要及时响应，也就是说当thread-1发出通知后，thread-2立即就执行，可以使用java.util.concurrent.CountDownLatch countDownLatch = new CountDownLatch(1);对象，此对象不用配合synchronize使用，countDownLatch.await()方法进入等待，countDownLatch.countDown();发出通知。CountDownLatch的计数器减为0 才会唤醒等待的线程;
5 单例与多线程结合
常见的单例模式有两种类型：
- 饥饿模式 ： 初始化的时候就实例化对象
- 懒汉模式 ： 在调用方法的时候才实例化对象
但是在多线程中建议使用以下2种模式
- dubble check instance
- static inner class (建议使用这一种)
（1）Dubble Check
public class DubbleCheck {
private static DubbleCheck dc;
private DubbleCheck(){
}
public static DubbleCheck getInstance(){
if( null == dc ){
synchronized (DubbleCheck.class) {
if( null == dc ){
System.out.println("实例化...");
dc = new DubbleCheck();
}
}
}
return dc;
}
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(DubbleCheck.getInstance().hashCode());
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(DubbleCheck.getInstance().hashCode());
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(DubbleCheck.getInstance().hashCode());
}
});
t1.start();
t2.start();
t3.start();
}
}
（2）Static Inner Class
public class InnerSingleton {
private InnerSingleton(){}
private static class Singleton{
private static InnerSingleton single = new InnerSingleton();
private Singleton(){}
}
public static InnerSingleton getInstance(){
return Singleton.single;
}
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(InnerSingleton.getInstance().hashCode());
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(InnerSingleton.getInstance().hashCode());
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(InnerSingleton.getInstance().hashCode());
}
});
t1.start();
t2.start();
t3.start();
}
}
5 同步类容器
同步类容器都是线程安全的，例如Vector、HashTable等。但是在某些场景下可能需要加锁来保护复合操作，例如：迭代（反复访问元素，遍历完容器中所有的元素），跳转（根据指定的顺序找到当前元素的下一个元素），以及条件运算。这些复合操作在多线程并发地修改容器时，可能会出现意外的行为，最经典的就是java.util.ConcurrentModificationException，原因是当容器迭代的工程中，并发地修改了内容，这是由于早期迭代器设计的时候并没有考虑并发修改的问题。
传统的同步类容器（Vector,HashTable）,这些容器的同步功能都是有JDK的Collections.synchronized***等工厂方法去创建实现的。其底层的机制无非就是用传统的synchronized关键字对每一个公用的方法都进行同步，使得每次只能有一个线程访问容器状态。这样一来必然就会降低性能。
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;
public class Modification {
public static void main(String[] args) {
final Vector<String> vector = new Vector<String>();
for( int i = 0; i < 50; i++ ){
vector.add("str_" + i);
}
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
Iterator<String> it = vector.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for( int i = 50; i < 100; i++){
vector.add("str_" + i);
}
}
});
t1.start();
t2.start();
Collections.synchronizedList(new ArrayList<>());
Collections.synchronizedMap(new HashMap<>());
Collections.synchronizedCollection(new ArrayList<>());
}
}
6 并发类容器
JDK1.5之后提供的并发类容器来取代同步类容器，以提高性能。
(1) ConcurrentMap
有2个实现类
- ConcurrentHashMap 其功能类似于HashMap，但它是线程安全的，并且支持并发的。
- ConcurrentSkipListMap(支持并发排序功能，以弥补ConcurrentHashMap) 其功能类似于TreeMap
ConcurrentHashMap内部使用段（Segment）来表示这些不同的部分，每个段其实就是一个小的HashTable,他们都有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行。把一个整体分成 16 个段，也就是最高支持16个线程的并发修改操作，这也是在多线程场景时减少锁的粒度从而降低锁竞争的一种方案。并且代码中大多共享变量使用volatile关键字声明，目的是第一时间获取修改的内容，性能非常好。
(2) Copy-On-Write
有2个实现类 （适用于读多写少的场景）
- CopyOnWriteArrayList
- CopyOnWriteArraySet
CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy,复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。
7 并发Queue
在并发队列上JDK提供了两套实现，一个是ConcurrentLinkedQueue为代表的高性能队列（非阻塞），一个是以BlockingQueue接口为代表的阻塞队列
（1）ConcurrentLinkedQueue
是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue。它是一个基于链接点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的，尾是最近加入的，该队列不允许null元素
- add()和offer()都是加入元素，在ConcurrentLinkedQueue中，这两个方法没有任何区别
- poll()和peek()都是取头元素节点，区别在于前者会删除元素，后者不会。
注意：在遍历ConcurrentLinkedQueue获取元素时可能需要判断ConcurrentLinkedQueue的大小是否大于0，但是根据ConcurrentLinkedQueue的API，如果直接调用ConcurrentLinkedQueue.size()方法来获取队列的大小，会导致性能大大降低，因为ConcurrentLinkedQueue.size()会循环遍历一次ConcurrentLinkedQueue来计算大小。所以在进行ConcurrentLinkedQueue为空判断时可以使用ConcurrentLinkedQueue.isEmpty()来判断。
另外在使用ConcurrentLinkedQueue进行原子操作如直接进行：queue.add(obj);或者queue.poll(obj);，这样我们自己不需要做任何同步。但如果进行非原子操作时同样需要增加synchronized来保证同步，否则会出现脏读数据。例如：
if(!queue.isEmpty()) {
queue.poll(obj);
}
我们很难保证，在调用了isEmpty()之后，poll()之前，这个queue没有被其他线程修改。
所以对于这种情况，我们还是需要自己同步：
synchronized(queue) {
if(!queue.isEmpty()) {
queue.poll(obj);
}
}
（2）BlockingQueue
- ArrayBlockingQueue：基于数组的阻塞队列实现，在ArrayBlockingQueue内部，维护了一个定长数组，以便缓存队列中的数据对象，其内部没有实现读写分离，也就意味着生产和消费不能完全并行，长度是需要定义的，可以指定先进先出或者先进后出，也叫有界队列，在很多场合非常适合使用。
- LinkedBlockingQueue：基于链表的阻塞队列。同ArrayBlockingQueue类似，其内部也维持着一个数据缓冲队列（该队列有一个链表构成），LinkedBlockingQueue之所以能够高效的处理并发数据，是因为其内部实现采用分离锁（读写分离两个锁），从而实现生产者和消费者操作的完全并行运行。他是一个无界队列，但是也可初始化时指定固定大小，不指定则为无界。
- SynchronousQueue：一种没有缓冲的队列，生产者产生的数据直接会被消费者获取并消费。
- PriorityBlockingQueue：基于优先级的阻塞队列（优先级的判断通过构造函数传入的Compator对象来决定，也就是说传入队列的对象必须实现Comparable接口），在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁，他也是一个无界的队列
DelayQueue：带有延迟时间的Queue，其中的元素只有当其指定的延迟时间到了，才能够从队列中获取该元素。DelayQueue中的元素必须实现Delayed接口，DelayQueue是一个没有大小限制的队列，应用场景很多，比如对缓存超时的数据进行移除、任务超时处理、空闲连接的关闭等等。线程会堵塞在DelayQueue.take();
WangBa.java
package com.test.sync5; import java.util.concurrent.DelayQueue; import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; public class WangBa extends Thread { private DelayQueue<WangMin> swQueue = new DelayQueue<WangBa.WangMin>(); public boolean yinye = true; public void shangji(String name, String id, int money){ WangMin wangMin = new WangMin(name, id, money); System.out.println(wangMin.toString()); this.swQueue.add(wangMin); } public void xiaji(WangMin w){ System.out.println("网名："+w.getName() + " 身份证："+w.getId() + "，时间到，下机. "); } @Override public void run() { // TODO Auto-generated method stub while(yinye){ try { WangMin w = this.swQueue.take(); //如果没有数据到期，取不到数据，此处会堵塞 System.out.println("获取到元素..."); xiaji(w); } catch (Exception e) { // TODO: handle exception } } } public static void main(String[] args) { System.out.println("网吧开始营业..."); WangBa siyu = new WangBa(); Thread shangwang = new Thread(siyu); shangwang.start(); siyu.shangji("路人甲", "123", 1); siyu.shangji("路人乙", "234", 10); siyu.shangji("路人丙", "345", 5); } static class WangMin implements Delayed{ private String name; private String id; private int money; private long endTime; private TimeUnit timeUnit = TimeUnit.SECONDS; public WangMin(String name, String id, int money) { this.name = name; this.id = id; this.money = money; this.endTime = 1000 * money + System.currentTimeMillis(); } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getId() { return id; } public void setId(String id) { this.id = id; } public long getEndTime() { return endTime; } public void setEndTime(long endTime) { this.endTime = endTime; } @Override public String toString() { // TODO Auto-generated method stub return "网名：" +this.name + " 身份证：" + this.id + "押金：" + this.money + "，开始上机..."; } @Override public int compareTo(Delayed o) { // TODO Auto-generated method stub WangMin w = (WangMin) o; return this.getDelay(this.timeUnit) - w.getDelay(timeUnit) > 0 ? 1 : 0; } @Override public long getDelay(TimeUnit unit) { // TODO Auto-generated method stub return endTime - System.currentTimeMillis(); } } }
扫一扫
197
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
