1.重入锁(ReentrantLock)
重入锁使用java.util.concurrent.locks.ReentrantLock类来实现，具有与synchronized关键字相似的功能。
1 package com.company;
2
3 import java.util.concurrent.locks.ReentrantLock;
4
5 public class User implements Runnable {
6 private ReentrantLock lock = new ReentrantLock();
7 static int i = 0;
8 @Override
9 public void run() {
10 lock.lock();
11 for (int j = 0; j < 10000000; j++) {
12 i++;
13 }
14 System.out.println(i);
15 lock.unlock();
16 }
17
18 public static void main(String[] args) throws InterruptedException {
19 //注意要使用同一个对象创建线程
20 User u = new User();
21 Thread t1 = new Thread(u);
22 Thread t2 = new Thread(u);
23 t1.start();
24 t2.start();
25 }
26 }
- 锁的时候响应中断
1 package com.company;
2
3 import java.util.concurrent.locks.ReentrantLock;
4
5 public class User implements Runnable {
6 private ReentrantLock lock1 = new ReentrantLock();
7 private ReentrantLock lock2 = new ReentrantLock();
8
9 @Override
10 public void run() {
11 //线程t1先持有lock1,休眠0.5秒尝试持有lock2
12 if(Thread.currentThread().getName().equals("t1")){
13 try {
14 lock1.lockInterruptibly();
15 Thread.sleep(500);
16 lock2.lockInterruptibly();
17 } catch (InterruptedException e) {
18 e.printStackTrace();
19 }
20 //线程t2先持有lock2,休眠0.5秒尝试持有lock1,但是lock1在被t1持有，导致死锁
21 //主线程休眠5秒后，中断线程t1,t1被中断，t2继续执行,执行完毕后退出。
22 }else{
23 try {
24 lock2.lockInterruptibly();
25 Thread.sleep(500);
26 lock1.lockInterruptibly();
27 } catch (InterruptedException e) {
28 e.printStackTrace();
29 }
30 }
31 if(lock1.isHeldByCurrentThread()){
32 lock1.unlock();
33 }
34 if(lock2.isHeldByCurrentThread()){
35 lock2.unlock();
36 }
37 }
38
39 public static void main(String[] args) throws InterruptedException {
40 //注意要使用同一个对象创建线程
41 User u = new User();
42 Thread t1 = new Thread(u,"t1");
43 Thread t2 = new Thread(u,"t2");
44 t1.start();
45 t2.start();
46 Thread.sleep(5000);
47 t1.interrupt();
48 }
49 }
- 设定锁的等待时间
1 package com.company;
2
3 import org.omg.PortableServer.THREAD_POLICY_ID;
4
5 import java.util.concurrent.TimeUnit;
6 import java.util.concurrent.locks.ReentrantLock;
7
8 public class User implements Runnable {
9 private ReentrantLock lock = new ReentrantLock();
10
11 @Override
12 public void run() {
13 try {
14 if(lock.tryLock(5, TimeUnit.SECONDS)){
15 System.out.println(Thread.currentThread().getName()+"成功获得锁");
16 Thread.sleep(6000);
17 }else{
18 System.out.println(Thread.currentThread().getName()+"获得锁失败");
19 }
20 } catch (InterruptedException e) {
21 e.printStackTrace();
22 }
23 }
24
25 public static void main(String[] args) throws InterruptedException {
26 //注意要使用同一个对象创建线程
27 User u = new User();
28 Thread t1 = new Thread(u,"t1");
29 Thread t2 = new Thread(u,"t2");
30 t1.start();
31 t2.start();
32 }
33 }
- 设定线程公平获得锁
公平锁需要维护有序队列，成本高。
1 package com.company;
2
3 import org.omg.PortableServer.THREAD_POLICY_ID;
4
5 import java.util.concurrent.TimeUnit;
6 import java.util.concurrent.locks.ReentrantLock;
7
8 public class User implements Runnable {
9 //还有一个带有boolean参数的构造方法，为true时多个线程公平的获得锁
10 private ReentrantLock lock = new ReentrantLock(true);
11
12 @Override
13 public void run() {
14 while(true){
15 lock.lock();
16 try {
17 System.out.println(Thread.currentThread().getName()+"获得锁");
18 Thread.sleep(100);
19 } catch (InterruptedException e) {
20 e.printStackTrace();
21 }
22 lock.unlock();
23 }
24 }
25
26 public static void main(String[] args) throws InterruptedException {
27 //注意要使用同一个对象创建线程
28 User u = new User();
29 Thread t1 = new Thread(u,"t1");
30 Thread t2 = new Thread(u,"t2");
31 t1.start();
32 t2.start();
33 }
34 }
- 重入锁的wait和notify
重入锁的等待唤醒使用Condition类，等待使用await()方法，唤醒使用signal()方法，
1 package com.company;
2 import java.util.concurrent.locks.Condition;
3 import java.util.concurrent.locks.ReentrantLock;
4
5 public class User implements Runnable {
6 public static ReentrantLock lock = new ReentrantLock();
7 public static Condition condition = lock.newCondition();
8
9 @Override
10 public void run() {
11 try {
12 lock.lock();
13 condition.await();
14 System.out.println("唤醒了");
15 } catch (InterruptedException e) {
16 e.printStackTrace();
17 }
18 lock.unlock();
19 }
20
21 public static void main(String[] args) throws InterruptedException {
22 //注意要使用同一个对象创建线程
23 User u = new User();
24 Thread t = new Thread(u);
25 t.start();
26 Thread.sleep(1000);
27 //condition只能用在lock块内
28 lock.lock();
29 condition.signal();
30 lock.unlock();
31 }
32 }
2.信号量(Semaphore)
synchronized关键字和重入锁同一时间只支持一个线程进入，信号量允许多个线程进入。
1 package com.company;
2 import java.util.concurrent.ExecutorService;
3 import java.util.concurrent.Executors;
4 import java.util.concurrent.Semaphore;
5
6 public class User implements Runnable {
7 final Semaphore semp = new Semaphore(5);
8
9 @Override
10 public void run() {
11 try {
12 semp.acquire();
13 Thread.sleep(1000);
14 System.out.println(Thread.currentThread().getName()+"执行完了");
15 } catch (InterruptedException e) {
16 e.printStackTrace();
17 }
18 semp.release();
19
20 }
21
22 public static void main(String[] args) throws InterruptedException {
23 //创建一个线程池，池里边有20个线程
24 ExecutorService executorService = Executors.newFixedThreadPool(20);
25 final User user= new User();
26 for (int i = 0; i < 20; i++) {
27 executorService.submit(user);
28 }
29 }
30 }
3.读写锁
读写锁应用于读的次数远大于写的次数的场景，因为2个线程同时读并没有对资源修改，所以可以同时读，但是但凡一个线程有写操作，就会阻塞其他线程
1 package com.company;
2
3
4 import java.util.concurrent.CountDownLatch;
5 import java.util.concurrent.locks.Lock;
6 import java.util.concurrent.locks.ReadWriteLock;
7 import java.util.concurrent.locks.ReentrantLock;
8 import java.util.concurrent.locks.ReentrantReadWriteLock;
9
10 public class Main {
11
12 public void readSth(){
13 try {
14 Thread.sleep(1000);
15 } catch (InterruptedException e) {
16 e.printStackTrace();
17 }
18 }
19
20 public void writeSth(){
21 try {
22 Thread.sleep(2000);
23 } catch (InterruptedException e) {
24 e.printStackTrace();
25 }
26 }
27 //注意reader类和writer类需要持有同一个类的锁，这2个类持有同一个Main对象
28 public static class Reader implements Runnable{
29 private ReadWriteLock readWriteLock;
30 private Lock readlock;
31 private CountDownLatch latch;
32 private Main obj;
33
34 public Reader(ReadWriteLock readWriteLock,CountDownLatch latch,Main obj){
35 this.readWriteLock = readWriteLock;
36 this.readlock = readWriteLock.readLock();
37 this.latch = latch;
38 this.obj = obj;
39 }
40
41
42 @Override
43 public void run() {
44 readlock.lock();
45 obj.readSth();
46 readlock.unlock();
47 latch.countDown();
48 }
49 }
50
51 public static class Writer implements Runnable{
52 private ReadWriteLock readWriteLock;
53 private Lock writelock;
54 private CountDownLatch latch;
55 private Main obj;
56
57 public Writer(ReadWriteLock readWriteLock,CountDownLatch latch,Main obj){
58 this.readWriteLock = readWriteLock;
59 this.writelock = readWriteLock.writeLock();
60 this.latch = latch;
61 this.obj = obj;
62 }
63
64
65 @Override
66 public void run() {
67 writelock.lock();
68 obj.writeSth();
69 writelock.unlock();
70 latch.countDown();
71 }
72 }
73 public static void main(String[] args) throws InterruptedException {
74 final long start = System.currentTimeMillis();
75 ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
76 final CountDownLatch latch = new CountDownLatch(25);
77 Main m = new Main();
78 for (int i = 0; i < 20; i++) {
79 Thread t = new Thread(new Reader(readWriteLock,latch,m));
80 t.start();
81 }
82 for (int i = 0; i < 5; i++) {
83 Thread t = new Thread(new Writer(readWriteLock,latch,m));
84 t.start();
85 }
86 latch.await();
87 final long end = System.currentTimeMillis();
88 final long cost = (end - start) /1000;
89 //执行时间11s
90 System.out.println(cost);
91 }
92 }
4.等待多个线程执行完的CountDownLatch
CountDownLatch可以让一个线程等待多个线程执行完后在执行。
1 package com.company;
2
3 import java.util.concurrent.CountDownLatch;
4
5 public class User implements Runnable {
6 private CountDownLatch c;
7
8 public User(CountDownLatch c){
9 this.c = c;
10 }
11
12 @Override
13 public void run() {
14 try {
15 Thread.sleep(2000);
16 } catch (InterruptedException e) {
17 e.printStackTrace();
18 }
19 c.countDown();
20
21 }
22
23 public static void main(String[] args) throws InterruptedException {
24 long start = System.currentTimeMillis();
25 CountDownLatch c = new CountDownLatch(10);
26 for (int i = 0; i < 10; i++) {
27 new Thread(new User(c)).start();
28 }
29 c.await();
30 long end = System.currentTimeMillis();
31 System.out.println((end-start)/1000+"秒后所有线程都执行完了");
32 }
33 }
5.反复等待多个线程执行完的CyclicBarrier（？）
1 package com.company;
2
3 import java.util.Random;
4 import java.util.concurrent.BrokenBarrierException;
5 import java.util.concurrent.CyclicBarrier;
6
7 public class CyclicBarrierDemo {
8 public static class Solider implements Runnable{
9 private String solider;
10 private final CyclicBarrier cyclic;
11
12 public Solider(String solider,CyclicBarrier cyclic) {
13 this.solider = solider;
14 this.cyclic = cyclic;
15 }
16
17 @Override
18 public void run() {
19 try {
20 //等士兵集合
21 cyclic.await();
22 doWork();
23 //等士兵完成任务
24 cyclic.await();
25 } catch (InterruptedException e) {
26 e.printStackTrace();
27 } catch (BrokenBarrierException e) {
28 e.printStackTrace();
29 }
30 }
31
32 void doWork() throws InterruptedException {
33 Thread.sleep(Math.abs(new Random().nextInt() % 10000));
34 System.out.println(solider+"任务完成");
35 }
36 }
37 //一批线程执行完了，最后执行什么
38 public static class BarrierRun implements Runnable{
39 boolean flag;
40 int N;
41
42 public BarrierRun(boolean flag,int N){
43 this.flag = flag;
44 this.N = N;
45 }
46 @Override
47 public void run() {
48 if(flag){
49 System.out.println("司令："+N+"个士兵完成任务");
50 }else{
51 System.out.println("司令："+N+"个士兵集合完毕");
52 flag = true;
53 }
54 }
55 }
56
57 public static void main(String[] args) {
58 final int N = 10;
59 boolean flag = false;
60 CyclicBarrier cyclicBarrier = new CyclicBarrier(N,new BarrierRun(flag,N));
61 System.out.println("集合队伍");
62 for (int i = 0; i < N; i++) {
63 System.out.println("士兵"+i+"报道");
64 new Thread(new Solider("士兵"+i,cyclicBarrier)).start();
65 }
66 }
67 }
6.线程阻塞（LockSupport）
LockSupport的park()方法可以阻塞当前线程。
LockSupport为每个线程准备一个许可，park()将许可变为不可用；unpark()将许可变为可用。
即使unpark()先执行，在碰到对应的park()也能继续执行。
1 package com.company;
2
3
4 import java.util.concurrent.locks.LockSupport;
5
6 public class User implements Runnable{
7 private static Object o = new Object();
8
9 @Override
10 public void run() {
11 synchronized (o){
12 System.out.println(Thread.currentThread().getName());
13 LockSupport.park();
14 }
15 }
16
17 public static void main(String[] args) throws InterruptedException {
18 User u = new User();
19 Thread t1 = new Thread(u);
20 Thread t2 = new Thread(u);
21 t1.start();
22 t2.start();
23 24 LockSupport.unpark(t2);
25 t1.join();
26 t2.join();
27 }
28 }
park()还可以响应中断。
1 package com.company;
2
3
4 import java.util.concurrent.locks.LockSupport;
5
6 public class User implements Runnable{
7 private static Object o = new Object();
8
9 @Override
10 public void run() {
11 synchronized (o){
12 LockSupport.park();
13 if(Thread.interrupted()){
14 System.out.println("线程中断了");
15 }
16 }
17 }
18
19 public static void main(String[] args) throws InterruptedException {
20 User u = new User();
21 Thread t1 = new Thread(u);
22 t1.start();
23 t1.interrupt();
24 }
25 }
7.限流算法
- 漏桶算法
- 令牌桶算法（Guava的RateLimiter）
1 import com.google.common.util.concurrent.RateLimiter;
2
3 public class User implements Runnable{
4 //设定每秒处理2个请求
5 static RateLimiter t = RateLimiter.create(2);
6
7 public void run() {
8 System.out.println(System.currentTimeMillis());
9 }
10
11 public static void main(String[] args) {
12 for (int i = 0; i < 50; i++) {
13 t.acquire();
14 new Thread(new User()).start();
15 }
16 }
17 }
来源：https://www.cnblogs.com/vshen999/p/12404615.html