文章目录
一、Atomic类
概念;
- 我们通过Atomic类（原子的）。由于某一些特别常见的操作，老是来回的加锁，加锁的情况特别多，所以干脆java就提供了这些常见的操作这么一些个类，这些类的内部就自动带了锁，当然这些锁的实现并不是synchronized重量级锁，而是CAS的操作来实现的（号称无锁）。
凡是以Atomic开头的都是用CAS这种操作来保证线程安全的这么一些个类。
AtomicInteger:
由于我们在工作开发中经常性的有那种需求，一个值所有的线程共同访问它往上递增，所以jdk专门提供了这样的一些类
-
AtomicInteger的意思就是里面包了一个Int类型，这个int类型的自增 count++是线程安全的，还有拿值等等是线程安全的，
-
像原来我们写m++你得加锁，在多线程访问的情况下，那现在我们可以用AtomicInteger了，它内部就已经帮我们实现了原子操作，直接写 count.incrementAndGet(); //count1++ 这个就相当于count++。原来我们对count是需要加锁的，现在就不需要加锁了。
Atomic类案例:
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
public class T00_00_IPlusPlus2 {
private static AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws Exception {
Thread[] threads = new Thread[100];
CountDownLatch latch = new CountDownLatch(threads.length);
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 10000; j++) {
count.incrementAndGet();
}
latch.countDown();
});
}
for (Thread t : threads) {
t.start();
}
latch.await();
System.out.println(count);
}
}
详细分析:提升–05—并发编程之—原子性—CAS
cas是cpu的原语支持，也就是说cas操作是cpu指令级别上的支持，中间不能被打断。
二、synchronized、Atomic类、LongAdder 效率比较
需求:
很多线程对一个数进行递增这个事儿，我们工作当中经常会碰上，比如说在秒杀的时候。那么，这三种哪个效率更高一些呢?
- 模拟了很多个线程对一个数进行递增
- synchronized
- Atomic类
- LongAdder
代码实现:
public class T02_AtomicVsSyncVsLongAdder {
private static final int THREAD_COUNT = 50;
private static final int LOOPS_COUNT = 100_0000;
static long count2 = 0L;
static AtomicLong count1 = new AtomicLong(0L);
static LongAdder count3 = new LongAdder();
public static void main(String[] args) throws Exception {
Thread[] threads = new Thread[THREAD_COUNT];
for (int i = 0; i < threads.length; i++) {
threads[i] =
new Thread(() -> {
for (int k = 0; k < LOOPS_COUNT; k++) count1.incrementAndGet();
});
}
long start = System.currentTimeMillis();
for (Thread t : threads) t.start();
for (Thread t : threads) t.join();
long end = System.currentTimeMillis();
//TimeUnit.SECONDS.sleep(10);
System.out.println("Atomic: " + count1.get() + " time " + (end - start));
//-----------------------------------------------------------
Object lock = new Object();
for (int i = 0; i < threads.length; i++) {
threads[i] =
new Thread(new Runnable() {
@Override
public void run() {
for (int k = 0; k < LOOPS_COUNT; k++)
synchronized (lock) {
count2++;
}
}
});
}
start = System.currentTimeMillis();
for (Thread t : threads) t.start();
for (Thread t : threads) t.join();
end = System.currentTimeMillis();
System.out.println("Sync: " + count2 + " time " + (end - start));
//----------------------------------
for (int i = 0; i < threads.length; i++) {
threads[i] =
new Thread(() -> {
for (int k = 0; k < LOOPS_COUNT; k++) count3.increment();
});
}
start = System.currentTimeMillis();
for (Thread t : threads) t.start();
for (Thread t : threads) t.join();
end = System.currentTimeMillis();
//TimeUnit.SECONDS.sleep(10);
System.out.println("LongAdder: " + count1.longValue() + " time " + (end - start));
}
static void microSleep(int m) {
try {
TimeUnit.MICROSECONDS.sleep(m);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
分析:
为什么Atomic要比Sync快？
- 因为Atomic不加锁，是进行cas比较.刚刚我们说了synchronized是要加锁的，有可能它要去操作系统申请重量级锁，所以synchronized效率偏低，在这种情形下效率偏低。
LongAdder为什么要比Atomicx效率要高呢？
- 是因为LongAdder的内部做了一个分段锁，类似于分段锁的概念。
- 在它内部的时候，会把一个值放到一个数组里，比如说数组长度是4，最开始是0，1000个线程，250个线程锁在第一个数租元素里，以此类推，每一个都往上递增算出来结果在加到一起。
总结:
我们跑起来对比LongAdder是效率最高的，你要是自己做实验的时候，把线程数变小了LongAdder未必有优势，循环数量少了LongAdder也未必有优势，所以，实际当中用哪种你要考虑一下你的实际并发有多高。
三、CountDownLatch—倒数门栓
概念:
CountDown叫倒数，Latch是门栓的意思（倒数的一个门栓，5、4、3、2、1数到了，我这个门栓就开了）
案例解析:
- 看下面的小程序，这小程序叫usingCountDownLatch，new了100个线程，接下来，又来了100个数量的CountDownLatch，什么意思，就是，这是一个门栓，门栓上记了个数threads.length是100，
- 每一个线程结束的时候我让 latch.countDown()，然后所有线程start()，再latch.await()，最后结束。那CountDown是干嘛使得呢，看latch.await()，它的意思是说给我看住门，给我插住不要动。每个线程执行到latch.await()的时候这个门栓就在这里等着，并且记了个数是100，每一个线程结束的时候都会往下CountDown，CountDown是在原来的基础上减1，一直到这个数字变成0的时候门栓就会被打开，这就是它的概念，它是用来等着线程结束的。
import java.util.concurrent.CountDownLatch;
public class T06_TestCountDownLatch {
private static long n = 0L;
public static void main(String[] args) {
System.out.println("start latch");
usingCountDownLatch();
}
private static void usingCountDownLatch() {
Thread[] threads = new Thread[100];
CountDownLatch latch = new CountDownLatch(threads.length);
for(int i=0; i<threads.length; i++) {
threads[i] = new Thread(()->{
synchronized (T06_TestCountDownLatch.class){
for (int j = 0; j < 10000; j++) {
n++;
}
}
latch.countDown();
});
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(n);
System.out.println("end latch");
}
}
当然用join可以
public class T06_TestCountDownLatch {
private static long n = 0L;
public static void main(String[] args) {
System.out.println("start");
usingCountDownLatch();
System.out.println("end");
}
private static void usingCountDownLatch() {
Thread[] threads = new Thread[100];
for(int i=0; i<threads.length; i++) {
threads[i] = new Thread(()->{
synchronized (T06_TestCountDownLatch.class){
for (int j = 0; j < 10000; j++) {
n++;
}
}
});
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
for (int i = 0; i < threads.length; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(n);
}
}
- 用join实际上不太好控制，必须要你线程结束了才能控制，
- 但是如果是一个门栓的话我在线程里不停的CountDown，在一个线程里就可以控制这个门栓什么时候往前走，用join我只能是当前线程结束了你才能自动往前走，当然用join可以，但是CountDown比它要灵活。
四、 CyclicBarrier—循环栅栏
概念:
- 来讲这个同步工具叫CyclicBarrier，意思是循环栅栏，这有一个栅栏，什么时候人满了就把栅栏推倒，哗啦哗啦的都放出去，出去之后扎栅栏又重新起来，再来人，满了，推倒之后又继续。
案例解析:
下面程序，两个参数，第二个参数不传也是可以的，就是满了之后不做任何事情。第一个参数是20，满了之后帮我调用第二个参数指定的动作，我们这个指定的动作就是一个Runnable对象，打印满人，发车。什么barrier.await()会被放倒，就是等够20个人了，后面也可以写你要做的操作 s。什么时候满了20人了就发车。下面第一种写法是满了之后我什么也不做，第二种写法是用Labda表达式的写法。这个意思就是线程堆满了，我们才能往下继续执行。
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class T07_TestCyclicBarrier {
public static void main(String[] args) {
//CyclicBarrier barrier = new CyclicBarrier(20);
CyclicBarrier barrier = new CyclicBarrier(20, () -> System.out.println("满人"));
for(int i=0; i<100; i++) {
new Thread(()->{
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
应用场景:
- 举例：CyclicBarrier的概念呢比如说一个复杂的操作，需要访问 数据库，需要访问网络，需要访问文件，有一种方式是顺序执行，挨个的都执行完，效率非常低，
- 这是一种方式，还有一种可能性就是并发执行，原来是1、2、3顺序执行，并发执行是不同的线程去执行不同的操作，有的线程去数据库找，有的线程去网络访问，有的线程去读文件，必须是这三个线程全部到位了我才能去进行，这个时候我们就可以用CyclicBarrier。
五、Phaser----阶段
概念:
- Phaser它就更像是结合了CountDownLatch和CyclicBarrier，翻译一下叫阶段。这个稍微复杂一些.
- Phaser是按照不同的阶段来对线程进行执行，就是它本身是维护着一个阶段这样的一个成员变量，当前我是执行到那个阶段，是第0个，还是第1个阶段啊等等，每个阶段不同的时候这个线程都可以往前走，有的线程走到某个阶段就停了，有的线程一直会走到结束。你的程序中如果说用到分好几个阶段执行 ，而且有的人必须得几个人共同参与的一种情形的情况下可能会用到这个Phaser。
- 有种情形很可能用到，如果你写的是遗传算法，遗传算法是计算机来模拟达尔文的进化策略所发明的一种算法，当你去解决这个问题的时候这个Phaser是有可能用的上的。这个东西更像是CyclicBarrier，栅栏这个东西是一个一个的栅栏，他原来是一个循环的栅栏，循环使用，但是这个栅栏是一个栅栏一个栅栏的。
案例解析:
- 好，来看我们自己模拟的一个小例子。模拟了一个结婚的场景，结婚是有好多人要参加的，因此，我们写了一个类Person是一个Runnable可以new出来，扔给Thread去执行，模拟我们每个人要做一些操作，有这么几种方法，arrive()到达、eat()吃、leave()离开、hug()拥抱这么几个。作为一个婚礼来说它会分成好几个阶段，第一阶段大家好都得到齐了，第二个阶段大家开始吃饭， 三阶段大家离开，第四个阶段新郎新娘入洞房，那好，每个人都有这几个方法，在方法的实现里头我就简单的睡了1000个毫秒，我自己写了一个方法，把异常处理写到了方法里了。
- 在看主程序，一共有五个人参加婚礼了，接下来新郎，新娘参加婚礼，一共七个人。它一start就好调用我们的run（）方法，它会挨着牌的调用每一个阶段的方法。那好，我们在每一个阶段是不是得控制人数，第一个阶段得要人到期了才能开始，二阶段所有人都吃饭，三阶段所有人都离开，但是，到了第四阶段进入洞房的时候就不能所有人都干这个事儿了。所以，要模拟一个程序就要把整个过程分好几个阶段，而且每个阶段必须要等这些线程给我干完事儿了你才能进入下一个阶段。
- 那怎么来模拟过程呢，我定义了一个phaser，我这个phaser是从Phaser这个类继承，重写onAdvance方法，前进，线程抵达这个栅栏的时候，所有的线程都满足了这个第一个栅栏的条件了onAdvance会被自动调用，目前我们有好几个阶段，这个阶段是被写死的，必须是数字0开始，onAdvance会传来两个参数phase是第几个阶段，registeredParties是目前这个阶段有几个人参加，每一个阶段都有一个打印，返回值false，一直到最后一个阶段返回true，所有线程结束，整个栅栏组，Phaser栅栏组就结束了。
- 我怎么才能让我的线程在一个栅栏面前给停住呢，就是调用phaser.arriveAndAwaitAdvance()这个方法，这个方法的意思是到达等待继续往前走，直到新郎新娘如洞房，其他人不在参与，调用phaser.arriveAndDeregister()
这个方法。还有可以调用方法phaser.register()往上加，不仅可以控制栅栏上的个数还可以控制栅栏上的等待数量，这个就叫做phaser。是给大家拓宽知识面用的。
package c_018_00_AtomicXXX;
import java.util.Random;
import java.util.concurrent.Phaser;
import java.util.concurrent.TimeUnit;
public class T09_TestPhaser2 {
static Random r = new Random();
static MarriagePhaser phaser = new MarriagePhaser();
static void milliSleep(int milli) {
try {
TimeUnit.MILLISECONDS.sleep(milli);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
phaser.bulkRegister(7);
for(int i=0; i<5; i++) {
new Thread(new Person("p" + i)).start();
}
new Thread(new Person("新郎")).start();
new Thread(new Person("新娘")).start();
}
static class MarriagePhaser extends Phaser {
@Override
protected boolean onAdvance(int phase, int registeredParties) {
switch (phase) {
case 0:
System.out.println("所有人都到齐了！" + registeredParties);
System.out.println();
return false;
case 1:
System.out.println("所有人都吃完了！" + registeredParties);
System.out.println();
return false;
case 2:
System.out.println("所有人都离开了！" + registeredParties);
System.out.println();
return false;
case 3:
System.out.println("婚礼结束！新郎新娘抱抱！" + registeredParties);
return true;
default:
return true;
}
}
}
static class Person implements Runnable {
String name;
public Person(String name) {
this.name = name;
}
public void arrive() {
milliSleep(r.nextInt(1000));
System.out.printf("%s 到达现场！\n", name);
phaser.arriveAndAwaitAdvance();
}
public void eat() {
milliSleep(r.nextInt(1000));
System.out.printf("%s 吃完!\n", name);
phaser.arriveAndAwaitAdvance();
}
public void leave() {
milliSleep(r.nextInt(1000));
System.out.printf("%s 离开！\n", name);
phaser.arriveAndAwaitAdvance();
}
private void hug() {
if(name.equals("新郎") || name.equals("新娘")) {
milliSleep(r.nextInt(1000));
System.out.printf("%s 洞房！\n", name);
phaser.arriveAndAwaitAdvance();
} else {
phaser.arriveAndDeregister();
//phaser.register()
}
}
@Override
public void run() {
arrive();
eat();
leave();
hug();
}
}
}
六、ReadWriteLock----读写锁
概念;
这个ReadWriteLock 是读写锁。读写锁的概念其实就是共享锁和排他锁，读锁就是共享锁，写锁就是排他锁
- 读锁 —共享锁
- 写锁 —排他锁
案例解析:
- 我们这有两个方法，read()读一个数据，write()写一个数据。read这个数据的时候我需要你往里头传一把锁，这个传那把锁你自己定，我们可以传自己定义的全都是排他锁，也可以传读写锁里面的读锁或写锁。write的时候也需要往里面传把锁，同时需要你传一个新值，在这里值里面传一个内容。我们模拟这个操作，读的是一个int类型的值，读的时候先上锁，设置一秒钟，完了之后read over，最后解锁unlock。再下面写锁，锁定后睡1000毫秒，然后把新值给value，write over后解锁，非常简单。
- new ReentrantReadWriteLock() 是ReadWriteLock的一种实现，在这种实现里头我又分出两把锁来，一把叫readLock，一把叫writeLock，通过他的方法readWriteLock.readLock()来拿到readLock对象，读锁我就拿到了。通过readWriteLock.writeLock()拿到writeLock对象。这两把锁在我读的时候扔进去，因此，读线程是可以一起读的，也就是说这18个线程可以一秒钟完成工作结束。所以使用读写锁效率会大大的提升。
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class T10_TestReadWriteLock {
private static int value;
static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
static Lock readLock = readWriteLock.readLock();
static Lock writeLock = readWriteLock.writeLock();
public static void read(Lock lock) {
try {
lock.lock();
Thread.sleep(1000);
System.out.println("read over!");
//模拟读取操作
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void write(Lock lock, int v) {
try {
lock.lock();
Thread.sleep(1000);
value = v;
System.out.println("write over!");
//模拟写操作
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
Runnable readR = ()-> read(readLock);
Runnable writeR = ()->write(writeLock, new Random().nextInt());
for(int i=0; i<18; i++) new Thread(readR).start();
for(int i=0; i<2; i++) new Thread(writeR).start();
}
}
七、Semaphore----信号灯
Semaphore主要用来控制同时运行的线程数,限流
概念:
-
我们来聊这个Semaphore，信号灯。可以往里面传一个数，permits是允许的数量，你可以想着有几盏信号灯，一个灯里面闪着数字表示到底允许几个来参考我这个信号灯。
-
s.acquire()这个方法叫阻塞方法，阻塞方法的意思是说我大概acquire不到的话我就停在这，acquire的意思就是得到。如果我 Semaphore s = new Semaphore(1) 写的是1，我取一下，acquire一下他就变成0，当变成0之后别人是acquire不到的，然后继续执行，线程结束之后注意要s.release()，执行完该执行的就把他release掉，release又把0变回去1，还原化。
-
默认Semaphore是非公平的，new Semaphore(2, true)第二个值传true才是设置公平。公平这个事儿是有一堆队列在哪儿等，大家伙过来排队。用这个车道和收费站来举例子，就是我们有四辆车都在等着进一个车道，当后面在来一辆新的时候，它不会超到前面去，要在后面排着这叫公平。
应用;
- Semaphore的含义就是限流，比如说你在买票，Semaphore写5就是只能有5个人可以同时买票。acquire的意思叫获得这把锁，线程如果想继续往下执行，必须得从Semaphore里面获得一个许可，他一共有5个许可用到0了你就得给我等着。
- 例如，有一个八条车道的机动车道，这里只有两个收费站，到这儿，谁acquire得到其中某一个谁执行。
案例解析:
import java.util.concurrent.Semaphore;
public class T11_TestSemaphore {
public static void main(String[] args) {
Semaphore s = new Semaphore(1, true);
new Thread(()->{
try {
s.acquire();
System.out.println("T1 running...");
Thread.sleep(200);
System.out.println("T1 running...");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
s.release();
}
}).start();
new Thread(()->{
try {
s.acquire();
System.out.println("T2 running...");
Thread.sleep(200);
System.out.println("T2 running...");
s.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
new Semaphore(1, true);所以只能同时运行一个线程,所以T1技术后,T2才能开始.
八、Exchanger----交换器
概念:
- 这个Exchanger是给大家扩宽知识面用的，看下面这个小程序，这里我们定义了一个Exchanger，Exchanger叫做交换器，俩人之间互相交换个数据用的。怎么交换呢，看这里，我第一个线程有一个成员变量叫s，然后exchanger.exchange(s)，第二个也是这样，t1线程名字叫T1，第二个线程名字叫T2。到最后，打印出来你会发现他们俩交换了一下。线程间通信的方式非常多，这只是其中一种，就是线程之间交换数据用的。
案例解析:
package c_018_00_AtomicXXX;
import java.util.concurrent.Exchanger;
public class T12_TestExchanger {
static Exchanger<String> exchanger = new Exchanger<>();
public static void main(String[] args) {
new Thread(()->{
String s = "T1";
try {
s = exchanger.exchange(s);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + s);
}, "t1").start();
new Thread(()->{
String s = "T2";
try {
s = exchanger.exchange(s);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + s);
}, "t2").start();
}
}
- Exchanger叫做交换器, 你可以把它想象成一个容器，这个容器有两个值，两个线程，有两个格的位置，第一个线程执行到exchanger.exchange的时候，阻塞，但是要注意我这个exchange方法的时候是往里面扔了一个值，你可以认为吧T1扔到第一个格子了，然后第二个线程开始执行，也执行到这句话了，exchange，他把自己的这个值T2扔到第二个格子里。
- 接下来这两个哥们儿交换一下，T1扔给T2，T2扔给T1，两个线程继续往前跑。exchange只能是两个线程之间，交换这个东西只能两两进行。
总结:
- Atomic类是基于cas算法来保证数据的一致性的；
- LongAdder的内部做了一个分段锁，类似于分段锁的概念
- 讲了CountDownLatch的用法，就是倒计时，什么时候计数完了，门栓打开，程序继续往下执行；
- CycliBarrier一个栅栏，循环使用，什么时候人满了，栅栏放倒大家冲过去；
- Phaser分阶段的栅栏；
- ReadWriteLock读写锁，重点掌握；
- Semaphore限流用的；
- Exchanger两个线程之间互相交换数据；
253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
