高并发学习总结

It's a long long story.Be patient!

Java并发系列——原子更新类

所在包：java.util.concurrent.atomic

1、原子更新基本类
•AtomicBoolean：原子更新布尔类型。
•AtomicInteger：原子更新整型。
•AtomicLong：原子更新长整型。
方法
•int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
•boolean compareAndSet（int expect，int update）：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。
•int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值。
•int getAndSet（int newValue）：以原子方式设置为new-Value的值，并返回旧值。
•void lazySet（int newValue）：最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

2、原子更新数组
•AtomicIntegerArray：原子更新整型数组里的元素。
•AtomicLongArray：原子更新长整型数组里的元素。
•AtomicReferenceArray：原子更新引用类型数组里的元素。
•AtomicIntegerArray类主要是提供原子的方式更新数组里的整型，其常用方法如下：
◦int addAndGet（int i，int delta）：以原子方式将输入值与数组中索引i的元素相加。
◦boolean compareAndSet（int i，int expect，int update）：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

public class AtomicIntegerArrayTest {
 
    static int[]  value = new int[] { 1, 2 };
 
    static AtomicIntegerArray ai    = new AtomicIntegerArray(value);
 
    public static void main(String[] args) {
        ai.getAndSet(0, 3);
        System.out.println(ai.get(0));
        System.out.println(value[0]);
    }
 
}

以下是输出的结果。
3
1
需要注意的是，数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组。

3、原子更新引用类型
•AtomicReference：原子更新引用类型。
•AtomicReferenceFieldUpdater：原子更新引用类型里的字段。
•AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，booleaninitialMark）。

public class AtomicReferenceTest {
 
    public static AtomicReference<User> atomicUserRef = new AtomicReference<User>();
    private static AtomicIntegerFieldUpdater<User> atomicIntegerFieldUpdater   
        = AtomicIntegerFieldUpdater.newUpdater(User.class, "old"); 
 
    public static void main(String[] args) {
        User user = new User("conan", 15);
        atomicUserRef.set(user);
        User updateUser = new User("Shinichi", 17);
        atomicUserRef.compareAndSet(user, updateUser);
        System.out.println(atomicUserRef.get().getName());
        System.out.println(atomicUserRef.get().getOld());
        System.out.println(atomicIntegerFieldUpdater.getAndIncrement(user)); 
    }
 
    public static class User {
        private String name;
        private volatile int old;
 
        public User(String name, int old) {
            this.name = name;
            this.old = old;
        }
 
        public String getName() {
            return name;
        }
 
        public int getOld() {
            return old;
        }
    }
}

 

 

一、简介

1.独占锁：是一种悲观的加锁策略，它避免了读/读冲突。如果某个只读线程获取了改锁，则其他只读线程只能等待，这种情况下就限制了不必要的并发性，因为读操作不会影响数据的一致性。（悲观锁）

2.共享锁：是一种乐观锁，放宽了加锁策略，允许多个执行读操作的线程同时访问资源。

分类：

独占锁：ReentrantLock,ReentrnatReadWriteLock.WriteLock;

共享锁：ReentrnatReadWriteLock.ReadLock,CycliBarrier,CountDownLatch,Semamphore

其他：wait(),notify(),@hxx,对应Condition的await和signal

前者是Object在代码中 用锁对象即可调用，后者一个即可，必须使用ReentrantLock生成。

final Lock lock=new ReentrantLock;

final Condition notFull=lock.newCondition;

synchronized与ReentrantLock：

后者是前者一种更高级的改进

1.面向对象，性能更好；

2.提供更多机制，如时间锁等候，可中断锁等候，锁投票等；

3.ReentrantLock提供了可轮询的锁请求，提供tryLock（）方法，而synchronized则会一直阻塞等待；

例：
 

Lock lock=new ReentrantLock;

if(lock.tryLock()){

try{

//manipulate protected state

}catch{

lock.unLock();

}

}else{

//资源正在被别人占用，先做别的事情，比如打印一行日志

}

 

二、重要的类

1.CountDownLatch——用于n个线程等待其余M个线程结束。

A CountDownLatch用给定的计数初始化。 await方法阻塞，直到由于countDown()方法的调用而导致当前计数达到零，之后所有等待线程被释放，并且任何后续的await 调用立即返回。 这是一个一次性的现象 - 计数无法重置。 如果您需要重置计数的版本，请考虑使用CyclicBarrier 。

A CountDownLatch是一种通用的同步工具，可用于多种用途。 一个CountDownLatch为一个计数的CountDownLatch用作一个简单的开/关锁存器，或者门：所有线程调用await在门口等待，直到被调用countDown()的线程打开。 一个CountDownLatch初始化N可以用来做一个线程等待，直到N个线程完成某项操作，或某些动作已经完成N次。

（1）构造器

CountDownLatch(int count)

构造一个以给定计数 CountDownLatch CountDownLatch。

（2）方法

void	await() 导致当前线程等到锁存器计数到零，除非线程是 interrupted 。
boolean	await(long timeout, TimeUnit unit) 使当前线程等待直到锁存器计数到零为止，除非线程为 interrupted或指定的等待时间过去。
void	countDown() 减少锁存器的计数，如果计数达到零，释放所有等待的线程。
long	getCount() 返回当前计数。
String	toString() 返回一个标识此锁存器的字符串及其状态。

（3）用例

//第一个是启动信号，防止任何工作人员进入，直到驾驶员准备好继续前进;
//第二个是完成信号，允许司机等到所有的工作人员完成。

public class TestCountDownLatch {
    static final int N = 10;

    public static void main(String args[]) {
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(N);

        for (int i = 0; i < N; i++) {
            new Thread(new Worker(startSignal, doneSignal)).start();
            System.out.println("===do something===");
            startSignal.countDown();
        }

        try {
            doneSignal.await();
            System.out.println("===all finish");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Worker类:

public class Worker implements Runnable {
    final CountDownLatch startSignal;
    final CountDownLatch doneSignal;

    public Worker(CountDownLatch startSignal,CountDownLatch doneSignal){
        this.startSignal=startSignal;
        this.doneSignal=doneSignal;
    }

    @Override
    public void run() {
        try {
            startSignal.await();
            System.out.println("===开始工作了！！===");
            doneSignal.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

2.CyclicBarrier——实现 M 个线程在barrier栅栏处互相等待，可以重用状态（所以叫cycli），1的计数器只能减不能重新赋值！

 

 

 

 

 

 

3.Semaphore——一个技术信号量,用于限制最多M个线程同时并发

示例：这是一个使用信号量来控制对项目池的访问的类：

public class TestSemaphore2 {

    static int N = 10;
    static Semaphore semaphore = new Semaphore(3);

    public static void main(String args[]) {
        for (int i = 0; i < N; i++) {
            int finalI = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();// 拿凭证，总共5张凭证，没拿到会阻塞， 不想阻塞可用tryAcquire
                        System.out.println("工人" + finalI + "占用一个机器在生产！");
                        Thread.sleep(5000);
                        System.out.println("工人" + finalI + "释放出机器！");
                        semaphore.release();//释放凭证
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

    }
}

使用acquire，没有拿到凭证的线程会阻塞，结果如下：

是用tryAcquire就不会阻塞，结果如下：

 

4.ReentrantLock——用于实现同步功能，与synchrnized相似，但是面向对象更灵活。

示例：

ReentrantLock takeLock = new ReentrantLock();

// 获取锁

takeLock.lock();

try {

// 业务逻辑

} finally {

// 释放锁

takeLock.unlock();

}

5.ReentrantReadWriteLock

4是其父类，根据名字可以看到这个类区分读写锁，与4的优势是  线程躲在数据结构中读取数据而少有修改时  这个用处更大。

读写锁实现三点功能：

（1）多个读互不干扰（2）多个写操作必须独占锁（3）读和写操作都要上锁

（**读写锁出现的意义，提升了读性能，不然就用4了）