javajavase

6 实现 Callable 接口

Java 5.0 在 java.util.concurrent 提供了一个新的创建执行线程的方式：Callable 接口
Callable 需要依赖FutureTask ，FutureTask 也可以用作闭锁

6.1 创建线程的四种方式

无返回

  1. 实现Runnable接口，重写run()
  2. 继承Thread类，重写run()

有返回

  1. 实现Callable接口，重写call()，利用FutureTask包装Callable，并作为task传入Thread构造函数

  2. 利用线程池

    6.2 Callable的使用

  3. 创建执行线程的方式三：实现 Callable 接口。 相较于实现 Runnable 接口的方式，方法可以有返回值，并且可以抛出异常

  4. 执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。 FutureTask 是 Future 接口的实现类 ```java class ThreadDemo implements Callable { @Override public Integer call() throws Exception {
    1.  int sum = 0;
    2.  for (int i = 0; i <= 100000; i++) {
    3.      sum += i;
    4.  }
    5.  return sum;
    } }

public class TestCallable {

  1. public static void main(String[] args) {
  2.     ThreadDemo td = new ThreadDemo();
  4.     // 1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
  5.     FutureTask<Integer> result = new FutureTask<>(td);
  6.     new Thread(result).start();
  8.     // 2.接收线程运算后的结果
  9.     try {
  10.         Integer sum = result.get();  // FutureTask 可用于 闭锁
  11.         System.out.println(sum);
  12.         System.out.println("------------------------------------");
  13.     } catch (InterruptedException | ExecutionException e) {
  14.         e.printStackTrace();
  15.     }
  16. }

}

  2. ---
  4. <a name="3d06b53a"></a>
  5. ## 7 -Lock 同步锁
  6. 在 Java 5.0 之前，协调共享对象的访问时可以使用的机制只有 synchronized 和 volatile 。Java 5.0 后增加了一些新的机制，但并不是一种替代内置锁的方法，而是当内 置锁不适用时，作为一种可选择的高级功能。<br />ReentrantLock 实现了 Lock 接口，并提供了与 synchronized 相同的互斥性和内存可见性。但相较于synchronized 提供了更高的处理锁的灵活性。<br />解决多线程安全问题的三种方式
  8. - jdk 1.5 前
  9.    - synchronized：隐式锁<br />1.同步代码块<br />2.同步方法
  10. - jdk 1.5 后
  11.    - 3.同步锁 Lock：显式锁<br />注意：是一个显示锁，需要通过 lock() 方法上锁，必须通过 unlock() 方法进行释放锁
  12. ```java
  13. public class TestLock {
  14.     public static void main(String[] args) {
  15.         Ticket ticket = new Ticket();
  17.         new Thread(ticket, "1号窗口").start();
  18.         new Thread(ticket, "2号窗口").start();
  19.         new Thread(ticket, "3号窗口").start();
  20.     }
  21. }
  23. class Ticket implements Runnable {
  24.     private int tick = 100;
  25.     private Lock lock = new ReentrantLock();
  27.     @Override
  28.     public void run() {
  29.         while(true) {
  30.             lock.lock();    // 上锁        
  31.             try {
  32.                 if(tick > 0) {
  33.                     try {
  34.                         Thread.sleep(200);
  35.                     } catch (InterruptedException e) {
  36.                     }        
  37.                     System.out.println(Thread.currentThread().getName() 
  38.                                        + " 完成售票，余票为：" + --tick);
  39.                 }
  40.             }finally{
  41.                 lock.unlock();    // 必须执行 因此放在finally中 释放锁
  42.             }
  43.         }
  44.     }
  45. }

8 Condition 控制线程通信

Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。
在 Condition 对象中，与 wait、notify 和 notifyAll 方法对应的分别是 await、signal 和 signalAll
Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，请使用其 newCondition() 方法。

8.1 使用Condition

使用Condition控制线程通信

  1. 如果不使用 synchronized 关键字保证同步，而是直接使用Lock对象来保证同步，则系统中不存在隐式的同步监视器，也就不能使用 wait() notify() notifyAll() 来进行线程通信了
  2. 当使用 lock 对象来保证同步时，Java提供了一个 Condition 类来保持协调，使用Condition可以让那些已经得到 lock 对象却无法继续执行的线程释放lock对象，Condition对象也可以唤醒其他处于等待状态的进程。

  3. Condition 实例被绑定在一个 Lock 对象上。要获得 Lock 实例的 Condition 实例，调用 Lock 对象的newCondition() 方法即可

    8.2 生产者和消费者案例

    使用synchronized方式 ```java public class TestProductorAndConsumer { public static void main(String[] args) {

    1.  Clerk clerk = new Clerk();
    2.  Productor productor = new Productor(clerk);
    3.  Consumer consumer = new Consumer(clerk);
    5.  new Thread(productor, "生产者A").start();
    6.  new Thread(consumer, "消费者B").start();
    8.  new Thread(productor, "生产者C").start();
    9.  new Thread(consumer, "消费者D").start();

    } }

class Clerk { // 店员 private int product = 0;

  1. public synchronized void get() {    // 进货
  2.     while (product >= 1) {    // 为了避免虚假唤醒问题，应该总是使用在循环中而不用if
  3.         System.out.println("产品已满！");
  4.         try {
  5.             this.wait();
  6.         } catch (InterruptedException e) {
  7.             e.printStackTrace();
  8.         }
  9.     }
  10.     System.out.println(Thread.currentThread().getName() + " : " + ++product);
  11.     this.notifyAll();
  12. }
  14. public synchronized void sale() {    // 销售
  15.     while (product <= 0) {    // 为了避免虚假唤醒问题，应该总是使用在循环中
  16.         System.out.println("缺货！");
  17.         try {
  18.             this.wait();
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23.     System.out.println(Thread.currentThread().getName() + " : " + --product);
  24.     this.notifyAll();
  25. }

}

class Productor implements Runnable { // 生产者 private Clerk clerk;

  1. public Productor(Clerk clerk) {
  2.     this.clerk = clerk;
  3. }
  5. @Override
  6. public void run() {
  7.     for (int i = 0; i < 20; i++) {
  8.         try {
  9.             Thread.sleep(200);
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.         clerk.get();
  14.     }
  15. }

}

class Consumer implements Runnable { // 消费者 private Clerk clerk;

  1. public Consumer(Clerk clerk) {
  2.     this.clerk = clerk;
  3. }
  5. @Override
  6. public void run() {
  7.     for (int i = 0; i < 20; i++) {
  8.         clerk.sale();
  9.     }
  10. }

}

  1. 使用Lock方式
  2. ```java
  3. public class TestProductorAndConsumer {
  4.     public static void main(String[] args) {
  5.         Clerk clerk = new Clerk();
  6.         Productor productor = new Productor(clerk);
  7.         Consumer consumer = new Consumer(clerk);
  9.         new Thread(productor, "生产者A").start();
  10.         new Thread(consumer, "消费者B").start();
  12.         new Thread(productor, "生产者C").start();
  13.         new Thread(consumer, "消费者D").start();
  14.     }
  15. }
  17. class Clerk {//店员
  18.     private int product = 0;
  19.     private Lock lock = new ReentrantLock();
  20.     private Condition condition = lock.newCondition();
  21.     private Condition condition2 = lock.newCondition();
  23.     public void get() {    // 进货
  24.         lock.lock();
  25.         try {
  26.             while (product >= 1) {
  27.                 System.out.println("产品已满！");
  28.                 try {
  29.                     condition.await();
  30.                 } catch (InterruptedException e) {
  31.                     e.printStackTrace();
  32.                 }
  33.             }
  34.             System.out.println(Thread.currentThread().getName() + " : " + ++product);
  35.             condition2.signalAll();
  36.         } finally {
  37.             lock.unlock();
  38.         }
  39.     }
  41.     public void sale() {    // 销售
  42.         lock.lock();
  43.         try {
  44.             while (product <= 0) {
  45.                 System.out.println("缺货！");
  46.                 try {
  47.                     condition2.await();
  48.                 } catch (InterruptedException e) {
  49.                     e.printStackTrace();
  50.                 }
  51.             }
  52.             System.out.println(Thread.currentThread().getName() + " : " + --product);
  53.             condition.signalAll();
  54.         } finally {
  55.             lock.unlock();
  56.         }
  57.     }
  58. }
  61. class Productor implements Runnable {    // 生产者
  62.     private Clerk clerk;
  64.     public Productor(Clerk clerk) {
  65.         this.clerk = clerk;
  66.     }
  68.     @Override
  69.     public void run() {
  70.         for (int i = 0; i < 20; i++) {
  71.             try {
  72.                 Thread.sleep(200);
  73.             } catch (InterruptedException e) {
  74.                 e.printStackTrace();
  75.             }
  76.             clerk.get();
  77.         }
  78.     }
  79. }
  82. class Consumer implements Runnable {    // 消费者
  83.     private Clerk clerk;
  85.     public Consumer(Clerk clerk) {
  86.         this.clerk = clerk;
  87.     }
  89.     @Override
  90.     public void run() {
  91.         for (int i = 0; i < 20; i++) {
  92.             clerk.sale();
  93.         }
  94.     }
  95. }

image.png

8.3 线程按序交替

要求：编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要 求输出的结果必须按顺序显示。 如：ABCABCABC…… 依次递归

  1. public class TestABCAlternate {
  2.     public static void main(String[] args) {
  3.         AlternateDemo ad = new AlternateDemo();
  5.         new Thread(new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 for (int i = 1; i <= 10; i++) {
  9.                     ad.loopA(i);
  10.                 }
  11.             }
  12.         }, "A").start();
  14.         new Thread(new Runnable() {
  15.             @Override
  16.             public void run() {
  17.                 for (int i = 1; i <= 10; i++) {
  18.                     ad.loopB(i);
  19.                 }
  20.             }
  21.         }, "B").start();
  23.         new Thread(new Runnable() {
  24.             @Override
  25.             public void run() {
  26.                 for (int i = 1; i <= 10; i++) {
  27.                     ad.loopC(i);
  28.                 }
  29.             }
  30.         }, "C").start();
  31.     }
  32. }
  35. class AlternateDemo {
  36.     private int number = 1;
  37.     Lock lock = new ReentrantLock();
  38.     Condition condition1 = lock.newCondition();
  39.     Condition condition2 = lock.newCondition();
  40.     Condition condition3 = lock.newCondition();
  42.     /**
  43.      * @param totalLoop 循环第几轮
  44.      */
  45.     public void loopA(int totalLoop) {
  46.         lock.lock();
  48.         try {
  49.             if (number != 1) {
  50.                 condition1.await();
  51.             }
  52.             for (int i = 1; i <= 1; i++) {
  53.                 System.out.println(Thread.currentThread().getName()
  54.                                    + "\t" + i + "\t" + totalLoop);
  55.             }
  56.             number = 2;
  57.             condition2.signal();
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.         } finally {
  61.             lock.unlock();
  62.         }
  63.     }
  65.     public void loopB(int totalLoop) {
  66.         lock.lock();
  67.         try {
  68.             if (number != 2) {
  69.                 condition2.await();
  70.             }
  71.             for (int i = 1; i <= 1; i++) {
  72.                 System.out.println(Thread.currentThread().getName()
  73.                                    + "\t" + i + "\t" + totalLoop);
  74.             }
  75.             number = 3;
  76.             condition3.signal();
  77.         } catch (Exception e) {
  78.             e.printStackTrace();
  79.         } finally {
  80.             lock.unlock();
  81.         }
  82.     }
  84.     public void loopC(int totalLoop) {
  85.         lock.lock();
  86.         try {
  87.             if (number != 3) {
  88.                 condition3.await();
  89.             }
  90.             for (int i = 1; i <= 1; i++) {
  91.                 System.out.println(Thread.currentThread().getName()
  92.                                    + "\t" + i + "\t" + totalLoop);
  93.             }
  94.             number = 1;
  95.             condition1.signal();
  96.         } catch (Exception e) {
  97.             e.printStackTrace();
  98.         } finally {
  99.             lock.unlock();
  100.         }
  101.     }
  102. }

image.png

9 ReadWriteLock 读写锁

ReadWriteLock 维护了一对相关的锁，一个用于只读操作， 另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的
ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。 ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性 可以完全不需要考虑加锁操作

  • 写写/读写 需要“互斥”

  • 读读 不需要互斥 ```java public class TestReadWriteLock { public static void main(String[] args) {

    1.   ReadWriteLockDemo rw = new ReadWriteLockDemo();
    3.   new Thread(new Runnable() {
    4.       @Override
    5.       public void run() {
    6.           rw.set((int)(Math.random() * 101));
    7.       }
    8.   }, "write").start();
    10.   for (int i = 0; i < 100; i++) {
    11.       new Thread(new Runnable() {
    12.           @Override
    13.           public void run() {
    14.               rw.get();
    15.           }
    16.       }).start();
    17.   }

    } }

class ReadWriteLockDemo { private int number = 0; private ReadWriteLock lock = new ReentrantReadWriteLock();

  1. public void get() {    // 读
  2.     lock.readLock().lock();    // 上锁
  3.     try {
  4.         System.out.println(Thread.currentThread().getName() + " : " + number);
  5.     } catch (Exception e) {
  6.         e.printStackTrace();
  7.     } finally {
  8.         lock.readLock().unlock();    // 释放锁
  9.     }
  10. }
  12. public void set(int number) { 
  13.     lock.writeLock().lock();
  14.     try {
  15.         System.out.println(Thread.currentThread().getName());
  16.         this.number = number;
  17.     } catch (Exception e) {
  18.         e.printStackTrace();
  19.     } finally {
  20.         lock.writeLock().unlock();
  21.     }
  22. }

}

  2. ---
  4. <a name="e1202f16"></a>
  5. ## 10 线程8锁
  6. 判断打印的 "one" or "two" ？
  8. 1. 两个普通同步方法，两个线程，标准打印， 打印结果?
  9. 1. 新增 Thread.sleep() 给 getOne()，打印结果?
  10. 1. 新增普通方法 getThree() , 打印结果?
  11. 1. 两个普通同步方法，两个 Number 对象，打印结果?
  12. 1. 修改 getOne() 为静态同步方法，打印结果?
  13. 1. 修改两个方法均为静态同步方法，一个 Number 对象，打印结果?
  14. 1. 一个静态同步方法，一个非静态同步方法，两个 Number 对象，打印结果?
  15. 1. 两个静态同步方法，两个 Number 对象，打印结果?
  17. 要想知道上面线程8锁的答案，需要知晓关键所在
  19. - ① 非静态方法的锁默认为  this（实例对象）,  静态方法的锁为对应的 Class 对象（类对象）
  20. - ② 某一个时刻，同一个对象，只能有一个线程持有锁，无论几个方法
  21. - ③ 锁静态方法，某一个时刻，不同实例对象也只能有一个对象持有锁
  22. ```java
  23. public class TestThread8Monitor {
  24.     public static void main(String[] args) {
  25.         Number number = new Number();
  26.         Number number2 = new Number();
  28.         new Thread(new Runnable() {
  29.             @Override
  30.             public void run() {
  31.                 number.getOne();
  32.             }
  33.         }).start();
  35.         new Thread(new Runnable() {
  36.             @Override
  37.             public void run() {
  38. //                number.getTwo();
  39.                 number2.getTwo();
  40.             }
  41.         }).start();
  43. //        new Thread(new Runnable() {
  44. //            @Override
  45. //            public void run() {
  46. //                number.getThree();
  47. //            }
  48. //        }).start();
  49.     }
  50. }
  52. class Number {
  53.     public static synchronized void getOne() {    // Number.class
  54.         try {
  55.             Thread.sleep(3000);
  56.         } catch (InterruptedException e) {
  57.         }
  58.         System.out.println("one");
  59.     }
  61.     public synchronized void getTwo() {    // this
  62.         System.out.println("two");
  63.     }
  65.     public void getThree() {
  66.         System.out.println("three");
  67.     }
  68. }

答案

  1. 两个普通同步方法，两个线程，一个 Number 对象，标准打印， 打印结果? //one two
  2. 新增 Thread.sleep() 给 getOne() ,打印结果? // —过了3秒— one two
  3. 新增普通方法 getThree() , 打印结果? //three —过了3秒— one two
  4. 两个普通同步方法，两个 Number 对象，打印结果? //two —过了3秒— one
  5. 修改 getOne() 为静态同步方法，打印结果? //two —过了3秒— one
  6. 修改两个方法均为静态同步方法，一个 Number 对象，打印结果? //—过了3秒— one two
  7. 一个静态同步方法，一个非静态同步方法，两个 Number 对象，打印结果? //two —过了3秒— one
  8. 两个静态同步方法，两个 Number 对象，打印结果? //—过了3秒— one two