基础

synchronized对某个对象加锁

  1. public class T {
  2.     private int count = 10;
  3.     private Object o = new Object();
  4.     public void m() {
  5.         synchronized(o) { // 任何线程要执行下面的代码，必须先拿到o的锁
  6.             count--;
  7.             System.out.println(Thread.currentThread().getName() + " count = " + count);
  8.         }
  9.     }
  10. }
  1. public class T {
  2.     private int count = 10;
  3.     public void m() {
  4.         synchronized (this) { // 任何线程要执行下面的代码，必须先拿到this的锁
  5.             count--;
  6.             System.out.println(Thread.currentThread().getName() + " count = " + count);
  7.         }
  8.     }
  9. }

synchronized对方法加锁

  1. public class T {
  2.     private int count = 10;
  3.     public synchronized void m() { //等同于在方法的代码执行时要synchronized(this)
  4.         count--;
  5.         System.out.println(Thread.currentThread().getName() + " count = " + count);
  6.     }
  7. }
  1. public class T {
  2.     private static int count = 10;
  3.     public synchronized static void m() { // 这里等同于synchronized(T.class)
  4.         count--;
  5.         System.out.println(Thread.currentThread().getName() + " count = " + count);
  6.     }
  7.     public static void mm() {
  8.         synchronized (T.class) {
  9.             count--;
  10.         }
  11.     }
  12. }

volatile

  1. // volatile不能保证原子性
  2. public class T implements Runnable {
  3.     private /*volatile*/ int count = 10000;
  4.     public /*synchronized*/ void run() {
  5.         for (int i = 0; i < 100; i++)
  6.             count--;
  7.         System.out.println(Thread.currentThread().getName() + " count = " + count);
  8.     }
  9.     public static void main(String[] args) {
  10.         T t = new T();
  11.         for (int i = 0; i < 100; i++) {
  12.             new Thread(t, "THREAD" + i).start();
  13.         }
  14.     }
  15. }
  1. // 保证线程可见性
  2. public class T01_HelloVolatile {
  3.     volatile boolean running = true; // 对比一下有无volatile的情况下，整个程序运行结果的区别
  4.     void m() {
  5.         System.out.println("m start");
  6.         while(running) { }
  7.         System.out.println("m end!");
  8.     }
  9.     public static void main(String[] args) {
  10.         T01_HelloVolatile t = new T01_HelloVolatile();
  11.         new Thread(t::m, "t1").start();
  12.         try {
  13.             TimeUnit.SECONDS.sleep(1);
  14.         } catch (InterruptedException e) {
  15.             e.printStackTrace();
  16.         }
  17.         t.running = false;
  18.     }
  19. }
  1. // volatile 引用类型（包括数组）只能保证引用本身的可见性，不能保证内部字段的可见性
  2. public class T02_VolatileReference1 {
  3.     boolean running = true;
  4.     volatile static T02_VolatileReference1 T = new T02_VolatileReference1();
  5.     void m() {
  6.         System.out.println("m start");
  7.         while(running) {
  8. //            try {
  9. //                TimeUnit.MILLISECONDS.sleep(10);
  10. //            } catch (InterruptedException e) {
  11. //                e.printStackTrace();
  12. //            } 
  13. //            这段代码被放开后程序可以正常执性，可能是JVM对volatile有优化，但是没有考证过具体的细节
  14.         }
  15.         System.out.println("m end!");
  16.     }
  17.     public static void main(String[] args) {
  18.         new Thread(T::m, "t1").start();
  19.         try {
  20.             TimeUnit.SECONDS.sleep(1);
  21.         } catch (InterruptedException e) {
  22.             e.printStackTrace();
  23.         }
  24.         T.running = false;
  25.     }
  26. }

synchronized特点

  1. // synchronized是可重入的，也就是说他是基于线程分配的
  2. public class T {
  3.     synchronized void m1() {
  4.         System.out.println("m1 start");
  5.         try {
  6.             TimeUnit.SECONDS.sleep(1);
  7.         } catch (InterruptedException e) {
  8.             e.printStackTrace();
  9.         }
  10.         m2();
  11.         System.out.println("m1 end");
  12.     }
  13.     synchronized void m2() {
  14.         try {
  15.             TimeUnit.SECONDS.sleep(2);
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  19.         System.out.println("m2");
  20.     }
  21.     public static void main(String[] args) {
  22.         new T().m1();
  23.     }
  24. }
  1. // 继承并覆盖方法也可以冲入
  2. public class T {
  3.     synchronized void m() {
  4.         System.out.println("m start");
  5.         try {
  6.             TimeUnit.SECONDS.sleep(1);
  7.         } catch (InterruptedException e) {
  8.             e.printStackTrace();
  9.         }
  10.         System.out.println("m end");
  11.     }
  12.     public static void main(String[] args) {
  13.         new TT().m();
  14.     }
  15. }
  16. class TT extends T {
  17.     @Override
  18.     synchronized void m() {
  19.         System.out.println("child m start");
  20.         super.m();
  21.         System.out.println("child m end");
  22.     }
  23. }
  1. // 遇到异常释放锁
  2. public class T {
  3.     int count = 0;
  4.     synchronized void m() {
  5.         System.out.println(Thread.currentThread().getName() + " start");
  6.         while(true) {
  7.             count ++;
  8.             System.out.println(Thread.currentThread().getName() + " count = " + count);
  9.             try {
  10.                 TimeUnit.SECONDS.sleep(1);
  11.             } catch (InterruptedException e) {
  12.                 e.printStackTrace();
  13.             }
  14.             if(count == 5) {
  15.                 int i = 1/0; // 此处抛出异常，锁将被释放
  16.                 System.out.println(i);
  17.             }
  18.         }
  19.     }
  20.     public static void main(String[] args) {
  21.         T t = new T();
  22.         Runnable r = () -> t.m();
  23.         new Thread(r, "t1").start();
  24.         try {
  25.             TimeUnit.SECONDS.sleep(3);
  26.         } catch (InterruptedException e) {
  27.             e.printStackTrace();
  28.         }
  29.         new Thread(r, "t2").start();
  30.     }
  31. }
  1. // 锁定某对象o，如果o的属性发生改变，不影响锁的使用但是如果o变成另外一个对象，则锁定的对象发生改变
  2. // 应该避免将锁定对象的引用变成另外的对象
  3. public class SyncSameObject {
  4.     /*final*/ Object o = new Object();
  5.     void m() {
  6.         synchronized (o) {
  7.             while (true) {
  8.                 try {
  9.                     TimeUnit.SECONDS.sleep(1);
  10.                 } catch (InterruptedException e) {
  11.                     e.printStackTrace();
  12.                 }
  13.                 System.out.println(Thread.currentThread().getName());
  14.             }
  15.         }
  16.     }
  17.     public static void main(String[] args) {
  18.         SyncSameObject t = new SyncSameObject();
  19.         // 启动第一个线程
  20.         new Thread(t::m, "t1").start();
  21.         try {
  22.             TimeUnit.SECONDS.sleep(3);
  23.         } catch (InterruptedException e) {
  24.             e.printStackTrace();
  25.         }
  26.         // 创建第二个线程
  27.         Thread t2 = new Thread(t::m, "t2");
  28.         t.o = new Object(); // 锁对象发生改变，所以t2线程得以执行，如果注释掉这句话，线程2将永远得不到执行机会
  29.         t2.start();
  30.     }
  31. }

面试题

1

实现一个容器，提供两个方法，add，size。写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。

WaitNotify

  1. public class WaitNotify {
  3.     List lists = new ArrayList();
  4.     public void add(Object o) { lists.add(o); }
  5.     public int size() { return lists.size(); }
  7.     static volatile boolean t2Start = false;
  9.     public static void main(String[] args) throws InterruptedException {
  10.         WaitNotify c = new WaitNotify();
  12.         final Object lock = new Object();
  14.         new Thread(() -> {
  15.             try {
  16.                 System.out.println("t1 start");
  17.                 for (int i = 0; i < 10; i++) {
  18.                     c.add(new Object());
  19.                     System.out.println("add " + i);
  20.                     synchronized (lock) {
  21.                         if (c.size() == 5) {
  22.                             if(t2Start)
  23.                                 lock.notify();
  24.                             lock.wait();
  25.                         }
  26.                     }
  27.                     TimeUnit.SECONDS.sleep(1);
  28.                 }
  29.             } catch (Exception e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }, "t1").start();
  34.         TimeUnit.SECONDS.sleep(1);
  36.         new Thread(() -> {
  37.             t2Start = true;
  38.             try {
  39.                 System.out.println("t2 start");
  40.                 while (true) {
  41.                     synchronized (lock) {
  42.                         if (c.size() != 5) {
  43.                             lock.wait();
  44.                         } else {
  45.                             System.out.println("size == 5");
  46.                             System.out.println("t2 end");
  47.                             lock.notify();
  48.                             break;
  49.                         }
  50.                     }
  51.                 }
  52.             } catch (Exception e) {
  53.                 e.printStackTrace();
  54.             }
  56.         }, "t2").start();
  57.     }
  58. }

AwaitSignal

  1. public class AwaitSignal {
  3.     List lists = new ArrayList();
  4.     public void add(Object o) { lists.add(o); }
  5.     public int size() { return lists.size(); }
  7.     static volatile boolean t2Start = false;
  9.     public static void main(String[] args) throws InterruptedException {
  10.         AwaitSignal c = new AwaitSignal();
  12.         ReentrantLock lock = new ReentrantLock();
  13.         Condition condition = lock.newCondition();
  15.         new Thread(() -> {
  17.             try {
  18.                 System.out.println("t1 start");
  19.                 for (int i = 0; i < 10; i++) {
  20.                     c.add(new Object());
  21.                     System.out.println("add " + i);
  22.                     lock.lock();
  23.                     if (c.size() == 5) {
  24.                         if (t2Start) {
  25.                             condition.signal();
  26.                         }
  27.                         condition.await();
  28.                     }
  29.                     lock.unlock();
  30.                     TimeUnit.SECONDS.sleep(1);
  31.                 }
  32.             } catch (Exception e) {
  33.                 e.printStackTrace();
  34.             }
  35.         }, "t1").start();
  37.         TimeUnit.SECONDS.sleep(7);
  39.         new Thread(() -> {
  40.             t2Start = true;
  41.             try {
  42.                 System.out.println("t2 start");
  43.                 while (true) {
  44.                     lock.lock();
  45.                     if (c.size() != 5) {
  46.                         condition.await();
  47.                     } else {
  48.                         System.out.println("size == 5");
  49.                         System.out.println("t2 end");
  50.                         // 通知t1继续执行
  51.                         condition.signalAll();
  52.                         lock.unlock();
  53.                         break;
  54.                     }
  55.                     lock.unlock();
  56.                 }
  57.             } catch (Exception e) {
  58.                 e.printStackTrace();
  59.             }
  61.         }, "t2").start();
  62.     }
  63. }

2

写一个固定容量同步容器，拥有put和get方法，能够支持2个生产者线程以及10个消费者线程的阻塞调用。

  1. public class MyContainer2<T> {
  2.     final private LinkedList<T> lists = new LinkedList<>();
  3.     final private int MAX = 10; // 最多10个元素
  4.     private int count = 0;
  6.     private Lock lock = new ReentrantLock();
  7.     private Condition producer = lock.newCondition();
  8.     private Condition consumer = lock.newCondition();
  10.     public void put(T t) {
  11.         try {
  12.             lock.lock();
  13.             /**
  14.              * 如果这个地方使用if不使用while，考虑一种情况
  15.              * t1和t2两个线程在此等待，突然一个signal将他俩都唤醒了
  16.              * t1抢到了资源，所以继续运行，又把队列加满了，然后释放了资源
  17.              * t2终于获得了资源，但此时队列实际上满的，t2不应该去再往队列里加一个
  18.              * 所以解决方案就是t2判断队列是不是满的，他发现是满的，就继续await
  19.              */
  20.             while (lists.size() == MAX) {
  21.                 producer.await();    // 一定要注意，这个方法会释放临界资源
  22.             }
  24.             lists.add(t);
  25.             ++count;
  26.             consumer.signalAll(); // 通知消费者线程进行消费
  27.         } catch (InterruptedException e) {
  28.             e.printStackTrace();
  29.         } finally {
  30.             lock.unlock();
  31.         }
  32.     }
  34.     public T get() {
  35.         T t = null;
  36.         try {
  37.             lock.lock();
  38.             while (lists.size() == 0) {
  39.                 consumer.await();
  40.             }
  41.             t = lists.removeFirst();
  42.             count--;
  43.             producer.signalAll(); // 通知生产者进行生产
  44.         } catch (InterruptedException e) {
  45.             e.printStackTrace();
  46.         } finally {
  47.             lock.unlock();
  48.         }
  49.         return t;
  50.     }
  52.     public static void main(String[] args) {
  53.         MyContainer2<String> c = new MyContainer2<>();
  54.         // 启动消费者线程
  55.         for (int i = 0; i < 10; i++) {
  56.             new Thread(() -> {
  57.                 for (int j = 0; j < 5; j++)
  58.                     System.out.println(c.get());
  59.             }, "c" + i).start();
  60.         }
  62.         try {
  63.             TimeUnit.SECONDS.sleep(2);
  64.         } catch (InterruptedException e) {
  65.             e.printStackTrace();
  66.         }
  68.         // 启动生产者线程
  69.         for (int i = 0; i < 2; i++) {
  70.             new Thread(() -> {
  71.                 for (int j = 0; j < 25; j++)
  72.                     c.put(Thread.currentThread().getName() + " " + j);
  73.             }, "p" + i).start();
  74.         }
  75.     }
  76. }

3

用线程顺序打印A1B2C3….Z26。

  1. public class WaitNotify {
  3.     private static volatile boolean t2Started = false;
  5.     public static void main(String[] args) {
  7.         final Object o = new Object();
  8.         char[] aI = "1234567".toCharArray();
  9.         char[] aC = "ABCDEFG".toCharArray();
  11.         new Thread(() -> {
  12.             try {
  13.                 synchronized (o) {
  14.                     if (!t2Started) {
  15.                         o.wait();
  16.                     }
  17.                     for (char c : aI) {
  18.                         System.out.print(c);
  19.                         o.notify();
  20.                         o.wait();
  21.                     }
  22.                     o.notify();
  23.                 }
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  27.         }, "t1").start();
  29.         new Thread(() -> {
  30.             t2Started = true;
  31.             try {
  32.                 synchronized (o) {
  33.                     for (char c : aC) {
  34.                         System.out.print(c);
  35.                         o.notify();
  36.                         o.wait();
  37.                     }
  38.                     o.notify();
  39.                 }
  40.             } catch (InterruptedException e) {
  41.                 e.printStackTrace();
  42.             }
  43.         }, "t2").start();
  44.     }
  45. }