并发编程几个常用工具

Bertha 。 2023-07-17 06:09 2阅读 0赞

## synchronized ##

很多人看到这个就认为这个是重量锁

1.  由于每个类创建的对象JVM默认是偏向锁，在不发生线程争加锁资源的时候只是偏向锁
2.  这个类的偏向锁t1在被撤销的时候，变成了轻量锁
3.  当撤销次数为20次的时候，后面的开始又变成了偏向锁t2
4.  当撤销次数达到40次的时候，这个类所有偏向锁都变成轻量锁
5.  中间如果发送线程争夺资源，直接是重量锁

//设置次数40次
            int time = 40;
            Vector<TianHeAir> list = new Vector<>();
            for (int i = 0; i < time; i++) { 
                //创建40个对象，默认偏向锁
                list.add(new TianHeAir(1000));
            }
            /** * TODO:40个对象都是偏向锁，偏向线程t1 */
            t1 = new Thread("t1") { 
                @Override
                public void run() { 
                    for (TianHeAir item : list) { 
                        synchronized (item) { 
                            System.out.println("偏向锁偏向t1线程");
                        }
                    }
                    LockSupport.unpark(t2);
                }
            };
    
            /** * TODO:t2线程对偏向锁进行操作（前20次撤销偏向锁t1，后20次新增偏向锁t2） * 1.释放每个对象得偏向锁t1 * 2.给每个对象加向锁偏向t2 * 前20次加偏向锁无效，变成轻量锁，第20次开始生效，变成偏向锁偏向t2 */
            t2 = new Thread("t2") { 
                @Override
                public void run() { 
                    LockSupport.park();
                    for (int i = 0; i < list.size(); i++) { 
                        synchronized (list.get(i)){ 
                            if (i < 20) { 
                                //当偏向锁被撤销时，jvm把该偏向锁变成了轻量锁
                                System.out.println("此时是轻量锁");
                            } else { 
                                //当这个类的偏向锁撤销次数到达20次时，jvm把轻量锁变成了偏向锁，偏向t2线程
                                System.out.println("此时是偏向锁偏向线程t2");
                            }
                        }
                    }
                    LockSupport.unpark(t3);
                }
            };
    
            /** * TODO:t3线程对偏向锁进行操作（前20次撤销偏向锁t2,这个类由于前面已经撤销了20次加上现在20次一共撤销了40次这个类的所有对象变为轻量锁，不再有偏向锁） * 1.释放每个对象得偏向锁t2 * 2.给每个对象加向锁偏向t3 * 前20次加偏向锁无效，变成轻量锁，第20次开始生效，变成偏向锁偏向t2 */
            t3 = new Thread("t3") { 
                @Override
                public void run() { 
                    LockSupport.park();
                    for (int i = 0; i < list.size(); i++) { 
                        synchronized (list.get(i)){ 
                            System.out.println("此时是轻量锁");
                        }
                    }
                }
            };
    
            t1.start();
            t2.start();
            t3.start();
            t3.join();
            System.out.println("当一个类偏向锁被撤销达到40次的时候，个类的任何对象都不在有偏向锁，都是轻量锁");

## ReentrantLock ##

轻量锁  
需要try…finally手动释放锁

## ReentrantReadWriteLock ##

1.  轻量锁
2.  有读锁和写锁
3.  可重入
4.  读读不互斥，读写互斥
5.  先加写锁在没释放的情况下可以加读锁，反之不行

## StampedLock ##

和ReentrantReadWriteLock很像，但是增加了一个乐观读，乐观读性能更优

public static void main(String[] args) { 
    
            StampedLock lock = new StampedLock();
    
            new Thread("t1"){ 
                @Override
                public void run() { 
                    //乐观读，会生成stamp
                    long stamp = lock.tryOptimisticRead();
                    int x = 1;
                    try { 
                        Thread.sleep(1000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    //校验stamp是否改变，没有则数据安全，由于没有加锁，无需释放
                    if (lock.validate(stamp)){ 
                        System.out.println(x);
                        return;
                    }
                    //否则乐观读失败，重新读锁
                    stamp = lock.readLock();
                    try{ 
                        x = 2;
                        System.out.println(x);
                    }finally { 
                        lock.unlock(stamp);
                    }
                }
            }.start();
    
    
            new Thread("t2"){ 
                @Override
                public void run() { 
                    //线程2直接用了读锁改变了这个锁的stamp值
                    long stamp = lock.readLock();
                    try { 
                        System.out.println("t2开始了读锁");
                    }finally { 
                        lock.unlockRead(stamp);
                    }
                }
            }.start();
        }

## semaphore ##

可以限制同时跑几个线程，可以做到消峰作用

## CountDownLatch ##

倒计时锁，可以等待执行多少次后主线程在执行

public static void main(String[] args) throws InterruptedException, ExecutionException { 
            //设定倒计时锁为5次
            CountDownLatch countLock = new CountDownLatch(5);
            //同时跑两个线程
            Semaphore semaphore = new Semaphore(2);
            ExecutorService pool = Executors.newFixedThreadPool(3);
            Future<Integer> t1 = pool.submit(new TestCountDownLatch(countLock, 5, semaphore));
            Future<Integer> t2 = pool.submit(new TestCountDownLatch(countLock, 5, semaphore));
            Future<Integer> t3 = pool.submit(new TestCountDownLatch(countLock, 5, semaphore));
            Future<Integer> t4 = pool.submit(new TestCountDownLatch(countLock, 5, semaphore));
            Future<Integer> t5 = pool.submit(new TestCountDownLatch(countLock, 5, semaphore));
            countLock.await();
            Integer result = t1.get() + t2.get() + t3.get() + t4.get() + t5.get();
            //线程池明明每次可以跑3个线程但是由于semaphore设定为2则每次只能执行2个
            System.out.println("主线程计算结果=" + result);
            pool.shutdown();
        }

@Data
    public class TestCountDownLatch implements Callable<Integer> { 
    
        private CountDownLatch countLock;
        private Integer num;
        private Semaphore semaphore;
    
        public TestCountDownLatch(CountDownLatch countLock, Integer num) { 
            this.countLock = countLock;
            this.num = num;
        }
    
        public TestCountDownLatch(CountDownLatch countLock, Integer num, Semaphore semaphore) { 
            this.countLock = countLock;
            this.num = num;
            this.semaphore = semaphore;
        }
    
    
        @Override
        public Integer call() throws Exception { 
            semaphore.acquire();
            System.out.println("开始执行计算工作");
            Integer result = 0;
            for (int i = 0; i <= num; i++) { 
                result = result + i;
            }
            Thread.sleep(1000);
            semaphore.release();
            countLock.countDown();
            return result;
    
        }
    
    }