JUC总结

//cas算法原理
class CompareAndSwap {
    private int value;
    //获取内存值
    public synchronized int get() {
        return value;
    }
    //比较
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        int oldValue = value;
        if (oldValue == expectedValue) {
            this.value = newValue;
        }
        return oldValue;
    }
    //设置
    public synchronized boolean compareAndSet(int expectedValue, int newValue) {
        return expectedValue == compareAndSwap(expectedValue, newValue);
    }
}

//使用方法：例如计算多线程的总共执行时间
public class TestCountDownLatch {
    public static void main(String[] args) throws InterruptedException {
        final CountDownLatch latch = new CountDownLatch(10);
        LatchDemo latchDemo = new LatchDemo(latch);
 
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            new Thread(latchDemo).start();
        }
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("执行耗时:"+(end-start));
    }
}
 
class LatchDemo implements Runnable {
    private CountDownLatch latch;
    public LatchDemo(CountDownLatch latch) {
        this.latch = latch;
    }
 
    @Override
    public void run() {
        synchronized (latch) {
            try {
                for (int i = 0; i < 50000; i++) {
                    if (i % 2 == 0) {
                        System.out.println(i);
                    }
                }
            } finally {
                latch.countDown();
            }
        }
    }
}

public class TestCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadDemo1 td = new ThreadDemo1();
 
        //1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
        FutureTask<Integer> result = new FutureTask<>(td);
        new Thread(result).start();
 
        //2.接收线程运算后的结果
        Integer sum = result.get();  //FutureTask 可用于 闭锁
        System.out.println(sum);
    }
}
 
class ThreadDemo1 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100000; i++) {
            sum += i;
        }
        return sum;
    }
}

public class TestLock {
   public static void main(String[] args) {
      Ticket ticket = new Ticket();
      new Thread(ticket, "1号窗口").start();
      new Thread(ticket, "2号窗口").start();
      new Thread(ticket, "3号窗口").start();
   }
}
 
class Ticket implements Runnable{
   private int tick = 100;
   private Lock lock = new ReentrantLock();
 
   @Override
   public void run() {
      while(true){
         lock.lock(); //上锁
         try{
            if(tick > 0){
               System.out.println(Thread.currentThread().getName() + " 完成售票，余票为：" + --tick);
            }
         }finally{
            lock.unlock(); //释放锁
         }
      }
   }
}

private Condition condition = lock.newCondition();
condition.await();
condition.signal();

class ReadWriteLock1 {
    private int num = 0;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    
    //读
    public void get() {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + ":" + num);
        } finally {
            lock.readLock().unlock();
        }
    }
 
    //写
    public void set(int num) {
        lock.writeLock().lock();
        try {
            this.num = num;
            System.out.println(Thread.currentThread().getName());
        } finally {
            lock.writeLock().unlock();
        }
    }
}