1.线程池

1.1newFixedThreadPool

  1. public class FixedTheadPoolTest {
  2.     public static void main(String[] args) {
  3.         ExecutorService executorService = Executors.newFixedThreadPool(4);
  4.         for (int i = 0; i < 100; i++) {
  5.             executorService.execute(new Task());
  6.         }
  7.     }
  8. }
  10. class Task implements Runnable {
  11.     @Override
  12.     public void run() {
  13.         try {
  14.             Thread.sleep(500);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.         System.out.println(Thread.currentThread().getName());
  19.     }
  20. }

1.2newSingleThreadExecutor

  1. public class FixedTheadPoolTest {
  2.     public static void main(String[] args) {
  3.         ExecutorService executorService = Executors.newFixedThreadPool(4);
  4.         for (int i = 0; i < 100; i++) {
  5.             executorService.execute(new Task());
  6.         }
  7.     }
  8. }
  10. class Task implements Runnable {
  11.     @Override
  12.     public void run() {
  13.         try {
  14.             Thread.sleep(500);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.         System.out.println(Thread.currentThread().getName());
  19.     }
  20. }

1.3newCachedThreadPool

  1. public class CacheTheadPoolTest {
  2.     public static void main(String[] args) {
  3.         ExecutorService executorService = Executors.newCachedThreadPool();
  4.         for (int i = 0; i < 100; i++) {
  5.             executorService.execute(new Task());
  6.         }
  7.     }
  8. }

1.4newScheduledThreadPool

  1. public class ScheduledTheadPoolTest {
  2.     public static void main(String[] args) {
  3.         ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
  4.         // 每隔5秒执行一次任务
  5. //        scheduledExecutorService.schedule(new Task(),5, TimeUnit.SECONDS);
  6.         // 最开始1秒 后续每隔3秒
  7.         scheduledExecutorService.scheduleAtFixedRate(new Task(), 1, 3, TimeUnit.SECONDS);
  8.     }
  9. }

1.5停止线程

  1. public class ShowDown {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         ExecutorService pool = Executors.newFixedThreadPool(10);
  4.         for (int i = 0; i < 100; i++) {
  5.             pool.execute(new ShutDownTask());
  6.         }
  7.         Thread.sleep(1500);
  8.         // 强制停止线程立即执行
  9.         List<Runnable> runnables = pool.shutdownNow();
  10.         // 在3秒钟内判断线程是否已停止
  11. //        pool.shutdown();
  12. //        boolean b = pool.awaitTermination(7L, TimeUnit.SECONDS);
  13. //        System.out.println(b);
  14. //        System.out.println(pool.isShutdown());
  15. //        pool.shutdown();
  16. //        // 已停止线程后再调用会报错
  17. ////        pool.execute(new ShutDownTask());
  18. //        // 开始结束后就会返回true
  19. //        System.out.println(pool.isShutdown());
  20. //        Thread.sleep(10000);
  21. //        // 测地执行完后才返回true
  22. //        System.out.println(pool.isTerminated());
  23.     }
  24. }
  26. class ShutDownTask implements Runnable {
  27.     @Override
  28.     public void run() {
  29.         try {
  30.             Thread.sleep(1500);
  31.             System.out.println(Thread.currentThread().getName());
  32.         } catch (InterruptedException e) {
  33.             System.out.println(Thread.currentThread().getName() + "被中断了");
  34.         }
  35.     }
  36. }

1.6钩子拒绝策略

  1. public class PauseBleThreadPool extends ThreadPoolExecutor {
  2.     private boolean isPaused;
  3.     private final ReentrantLock lock = new ReentrantLock();
  4.     private Condition unpaused = lock.newCondition();
  6.     public PauseBleThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
  7.         super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
  8.     }
  10.     @Override
  11.     protected void beforeExecute(Thread t, Runnable r) {
  12.         super.beforeExecute(t, r);
  13.         lock.lock();
  14.         try {
  15.             while (isPaused) {
  16.                 unpaused.await();
  17.             }
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         } finally {
  21.             lock.unlock();
  22.         }
  23.     }
  25.     private void pause() {
  26.         lock.lock();
  27.         try {
  28.             isPaused = true;
  29.         } finally {
  30.             lock.unlock();
  31.         }
  32.     }
  34.     public void resume() {
  35.         lock.lock();
  36.         try {
  37.             isPaused = false;
  38.             unpaused.signalAll();
  39.         } finally {
  40.             lock.unlock();
  41.         }
  42.     }
  44.     public static void main(String[] args) throws InterruptedException {
  45.         PauseBleThreadPool threadPool = new PauseBleThreadPool(10, 20, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
  46.         Runnable ru = () -> {
  47.             System.out.println("我被执行了");
  48.             try {
  49.                 Thread.sleep(1500);
  50.             } catch (InterruptedException e) {
  51.                 e.printStackTrace();
  52.             }
  53.         };
  54.         for (int i = 0; i < 100; i++) {
  55.             threadPool.execute(ru);
  56.         }
  57.         Thread.sleep(1500);
  58.         threadPool.pause();
  59.         System.out.println("线程池被暂停了");
  60.         threadPool.resume();
  61.         System.out.println("线程池被恢复了");
  62.     }
  63. }

2.锁

2.1 ReentrantLock经典案例

  1. /**
  2.  * 演示多线程预定电影院座位,1个座位只能卖给一个人
  3.  */
  4. public class CinemaBookSeat {
  5.     private static ReentrantLock lock = new ReentrantLock();
  7.     private static void bookSeat() {
  8.         lock.lock();
  9.         try {
  10.             System.out.println(Thread.currentThread().getName() + "开始预定座位");
  11.             TimeUnit.SECONDS.sleep(1);
  12.             System.out.println(Thread.currentThread().getName() + "完成预定座位");
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         } finally {
  16.             lock.unlock();
  17.         }
  18.     }
  20.     public static void main(String[] args) {
  21.         new Thread(CinemaBookSeat::bookSeat).start();
  22.         new Thread(CinemaBookSeat::bookSeat).start();
  23.         new Thread(CinemaBookSeat::bookSeat).start();
  24.         new Thread(CinemaBookSeat::bookSeat).start();
  25.     }
  26. }
  1. public class PrintLock {
  2.     static class Outputer {
  3.         Lock lock = new ReentrantLock();
  5.         public void output(String name) {
  6.             int len = name.length();
  7.             lock.lock();
  8.             try {
  9.                 for (int i = 0; i < len; i++) {
  10.                     System.out.print(name.charAt(i));
  11.                 }
  12.                 System.out.println("");
  13.             } finally {
  14.                 lock.unlock();
  15.             }
  16.         }
  17.     }
  19.     private void init() {
  20.         final Outputer outputer = new Outputer();
  21.         new Thread(() -> {
  22.             while (true) {
  23.                 try {
  24.                     Thread.sleep(5);
  25.                 } catch (InterruptedException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.                 outputer.output("中国近代历史");
  29.             }
  30.         }).start();
  32.         new Thread(() -> {
  33.             while (true) {
  34.                 try {
  35.                     Thread.sleep(5);
  36.                 } catch (InterruptedException e) {
  37.                     e.printStackTrace();
  38.                 }
  39.                 outputer.output("马克思主义");
  40.             }
  41.         }).start();
  42.     }
  44.     public static void main(String[] args) {
  45.         new PrintLock().init();
  46.     }
  47. }

2.2 公平锁和非公平锁案例

  1. public class FairLock {
  2.     public static void main(String[] args) {
  3.         PrintQueue printQueue = new PrintQueue();
  4.         Thread thread[] = new Thread[10];
  5.         for (int i = 0; i < 10; i++) {
  6.             thread[i] = new Thread(new Job(printQueue));
  7.         }
  9.         for (int i = 0; i < 10; i++) {
  10.             thread[i].start();
  11.             try {
  12.                 Thread.sleep(100);
  13.             } catch (InterruptedException e) {
  14.                 e.printStackTrace();
  15.             }
  16.         }
  17.     }
  18. }
  20. class PrintQueue {
  21.     // 设置为false就是非公平锁
  22.     private Lock queueLock = new ReentrantLock(true);
  24.     public void printJob(Object document) {
  25.         queueLock.lock();
  26.         try {
  27.             int duration = new Random().nextInt(10) + 1;
  28.             System.out.println(Thread.currentThread().getName() + "正在打印，需要" + duration);
  29.             try {
  30.                 Thread.sleep(duration * 1000);
  31.             } catch (InterruptedException e) {
  32.                 e.printStackTrace();
  33.             }
  34.         } finally {
  35.             queueLock.unlock();
  36.         }
  38.         queueLock.lock();
  39.         try {
  40.             int duration = new Random().nextInt(10) + 1;
  41.             System.out.println(Thread.currentThread().getName() + "正在打印，需要" + duration);
  42.             try {
  43.                 Thread.sleep(duration * 1000);
  44.             } catch (InterruptedException e) {
  45.                 e.printStackTrace();
  46.             }
  47.         } finally {
  48.             queueLock.unlock();
  49.         }
  50.     }
  51. }
  53. class Job implements Runnable {
  54.     PrintQueue printQueue;
  56.     public Job(PrintQueue printQueue) {
  57.         this.printQueue = printQueue;
  58.     }
  60.     @Override
  61.     public void run() {
  62.         System.out.println(Thread.currentThread().getName() + "开始打印");
  63.         printQueue.printJob(new Object());
  64.         System.out.println(Thread.currentThread().getName() + "打印完毕");
  65.     }
  66. }

2.3 ReentrantReadWriteLock 案例

  1. public class CinemaReadWrite {
  2.     private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
  3.     private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
  4.     private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
  6.     public static void read() {
  7.         readLock.lock();
  8.         try {
  9.             System.out.println(Thread.currentThread().getName() + "得到了读锁，正在读取");
  10.             Thread.sleep(1000);
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         } finally {
  14.             System.out.println(Thread.currentThread().getName() + "释放读锁");
  15.             readLock.unlock();
  16.         }
  17.     }
  19.     public static void write() {
  20.         writeLock.lock();
  21.         try {
  22.             System.out.println(Thread.currentThread().getName() + "得到了写锁，正在写入");
  23.             Thread.sleep(1000);
  24.         } catch (InterruptedException e) {
  25.             e.printStackTrace();
  26.         } finally {
  27.             System.out.println(Thread.currentThread().getName() + "释放写锁");
  28.             writeLock.unlock();
  29.         }
  30.     }
  32.     public static void main(String[] args) {
  33.         new Thread(()->read(),"Thread1").start();
  34.         new Thread(()->read(),"Thread2").start();
  35.         new Thread(()->write(),"Thread3").start();
  36.         new Thread(()->write(),"Thread4").start();
  37.     }
  38. }

2.3.1 头结点为写锁，读锁排队

  1. public static void main(String[] args) {
  2.         new Thread(()->write(),"Thread1").start();
  3.         new Thread(()->read(),"Thread2").start();
  4.         new Thread(()->read(),"Thread3").start();
  5.         new Thread(()->write(),"Thread4").start();
  6.         new Thread(()->read(),"Thread5").start();
  7.     }

2.3.2 头结点不为写锁时，读锁可以插队

  1. public class NonfairBargeDemo {
  3.     private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(false);
  4.     private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
  5.     private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
  7.     private static void read() {
  8.         System.out.println(Thread.currentThread().getName() + "开始尝试获取读锁");
  9.         readLock.lock();
  10.         try {
  11.             System.out.println(Thread.currentThread().getName() + "得到读锁，正在读取");
  12.             try {
  13.                 Thread.sleep(20);
  14.             } catch (InterruptedException e) {
  15.                 e.printStackTrace();
  16.             }
  17.         } finally {
  18.             System.out.println(Thread.currentThread().getName() + "释放读锁");
  19.             readLock.unlock();
  20.         }
  21.     }
  23.     private static void write() {
  24.         System.out.println(Thread.currentThread().getName() + "开始尝试获取写锁");
  25.         writeLock.lock();
  26.         try {
  27.             System.out.println(Thread.currentThread().getName() + "得到写锁，正在写入");
  28.             try {
  29.                 Thread.sleep(40);
  30.             } catch (InterruptedException e) {
  31.                 e.printStackTrace();
  32.             }
  33.         } finally {
  34.             System.out.println(Thread.currentThread().getName() + "释放写锁");
  35.             writeLock.unlock();
  36.         }
  37.     }
  39.     public static void main(String[] args) {
  40.         new Thread(() -> write(), "Thread1").start();
  41.         new Thread(() -> read(), "Thread2").start();
  42.         new Thread(() -> read(), "Thread3").start();
  43.         new Thread(() -> write(), "Thread4").start();
  44.         new Thread(() -> read(), "Thread5").start();
  45.         new Thread(() -> {
  46.             Thread thread[] = new Thread[1000];
  47.             for (int i = 0; i < 1000; i++) {
  48.                 thread[i] = new Thread(() -> {
  49.                     read();
  50.                 }, "子线程创建的Thread" + i);
  51.             }
  52.             for (int i = 0; i < 1000; i++) {
  53.                 thread[i].start();
  54.             }
  55.         }).start();
  56.     }
  57. }

2.4 锁的降级

  1. public class Upgrading {
  3.     private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(false);
  4.     private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
  5.     private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
  7.     private static void readUpgrading() {
  8.         System.out.println(Thread.currentThread().getName() + "开始尝试获取读锁");
  9.         readLock.lock();
  10.         try {
  11.             System.out.println(Thread.currentThread().getName() + "得到读锁，正在读取");
  12.             try {
  13.                 Thread.sleep(20);
  14.                 System.out.println(Thread.currentThread().getName() + "升级会带来阻塞");
  15.                 writeLock.lock();
  16.                 System.out.println(Thread.currentThread().getName() + "获取到了写锁，升级成功");
  17.             } catch (InterruptedException e) {
  18.                 e.printStackTrace();
  19.             }
  20.         } finally {
  21.             System.out.println(Thread.currentThread().getName() + "释放读锁");
  22.             readLock.unlock();
  23.         }
  24.     }
  26.     private static void writeDowngrading() {
  27.         System.out.println(Thread.currentThread().getName() + "开始尝试获取写锁");
  28.         writeLock.lock();
  29.         try {
  30.             System.out.println(Thread.currentThread().getName() + "得到写锁，正在写入");
  31.             try {
  32.                 Thread.sleep(40);
  33.                 readLock.lock();
  34.                 System.out.println("在不释放写锁的情况下，直接获取写锁，成功降级");
  35.             } catch (InterruptedException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         } finally {
  39.             readLock.unlock();
  40.             System.out.println(Thread.currentThread().getName() + "释放写锁");
  41.             writeLock.unlock();
  42.         }
  43.     }
  45.     public static void main(String[] args) throws InterruptedException {
  46.         System.out.println("先演示降级是可以的");
  47.         Thread thread1 = new Thread(() -> writeDowngrading(), "Thread1");
  48.         thread1.start();
  49.         thread1.join();
  50.         System.out.println("----------------");
  51.         System.out.println("演示升级是不行的");
  52.         Thread thread2 = new Thread(() -> readUpgrading(), "Thread2");
  53.         thread2.start();
  54.     }
  55. }

3.原子类

3.1 AtomicInteger

  1. public class AtomicIntegerDemo1 implements Runnable {
  2.     private static final AtomicInteger atomicInteger = new AtomicInteger();
  4.     public void incrementAtomic() {
  5.         atomicInteger.getAndIncrement();
  6.     }
  8.     private static volatile int basicCount = 0;
  10.     public void incrementBasic() {
  11.         basicCount++;
  12.     }
  14.     @Override
  15.     public void run() {
  16.         for (int i = 0; i < 10000; i++) {
  17.             incrementAtomic();
  18.             incrementBasic();
  19.         }
  20.     }
  22.     public static void main(String[] args) throws InterruptedException {
  23.         AtomicIntegerDemo1 r = new AtomicIntegerDemo1();
  24.         Thread thread1 = new Thread(r);
  25.         Thread thread2 = new Thread(r);
  26.         thread1.start();
  27.         thread2.start();
  28.         thread1.join();
  29.         thread2.join();
  30.         System.out.println("原子类的结果是：" + atomicInteger.get());
  31.         System.out.println("普通变量的结果是：" + basicCount);
  32.     }
  33. }

3.2 AtomicIntegerArray

  1. public class AtomicArrayDemo {
  2.     public static void main(String[] args) {
  3.         AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1000);
  5.         Thread[] threadsIncrementer = new Thread[100];
  6.         Thread[] threadsDecrementer = new Thread[100];
  8.         Incrementer incrementer = new Incrementer(atomicIntegerArray);
  9.         Decrementer decrementer = new Decrementer(atomicIntegerArray);
  11.         for (int i = 0; i < 100; i++) {
  12.             threadsDecrementer[i] = new Thread(decrementer);
  13.             threadsIncrementer[i] = new Thread(incrementer);
  14.             threadsDecrementer[i].start();
  15.             threadsIncrementer[i].start();
  17.         }
  19.         for (int i = 0; i < 100; i++) {
  20.             try {
  21.                 threadsDecrementer[i].join();
  22.                 threadsIncrementer[i].join();
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.         }
  28.         for (int i = 0; i < atomicIntegerArray.length(); i++) {
  29.             if(atomicIntegerArray.get(i)!=0){
  30.                 System.out.println("发现了错误"+i);
  31.             }
  32.         }
  33.         System.out.println("运行结束");
  34.     }
  35. }
  37. class Decrementer implements Runnable {
  38.     private AtomicIntegerArray array;
  40.     public Decrementer(AtomicIntegerArray array) {
  41.         this.array = array;
  42.     }
  44.     @Override
  45.     public void run() {
  46.         for (int i = 0; i < array.length(); i++) {
  47.             array.getAndIncrement(i);
  48.         }
  49.     }
  50. }
  52. class Incrementer implements Runnable {
  53.     private AtomicIntegerArray array;
  55.     public Incrementer(AtomicIntegerArray array) {
  56.         this.array = array;
  57.     }
  59.     @Override
  60.     public void run() {
  61.         for (int i = 0; i < array.length(); i++) {
  62.             array.getAndDecrement(i);
  63.         }
  64.     }
  65. }

3.3 AtomicIntegerFieldUpdater

  1. public class AtomicIntegerFieldUpdaterDemo implements Runnable {
  3.     static Candidate tom;
  4.     static Candidate peter;
  6.     public static AtomicIntegerFieldUpdater<Candidate> scoreUpdater = AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");
  8.     @Override
  9.     public void run() {
  10.         for (int i = 0; i < 10000; i++) {
  11.             peter.score++;
  12.             scoreUpdater.getAndIncrement(tom);
  13.         }
  14.     }
  16.     public static class Candidate {
  17.         volatile int score;
  18.     }
  20.     public static void main(String[] args) throws InterruptedException {
  21.         tom = new Candidate();
  22.         peter = new Candidate();
  23.         AtomicIntegerFieldUpdaterDemo r = new AtomicIntegerFieldUpdaterDemo();
  24.         Thread t1 = new Thread(r);
  25.         Thread t2 = new Thread(r);
  26.         t1.start();
  27.         t2.start();
  28.         t1.join();
  29.         t2.join();
  30.         System.out.println("普通变量：" + peter.score);
  31.         System.out.println("升级后的结果：" + tom.score);
  32.     }
  33. }