Java - 请说出与线程同步以及线程调度相关的方法。

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击人工智能教程

- wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；

- sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException异常；

- notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且与优先级无关；

- notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁的线程才能进入就绪状态；

补充：Java 5通过Lock接口提供了显式的锁机制（explicit lock），增强了灵活性以及对线程的协调。Lock接口中定义了加锁（lock()）和解锁（unlock()）的方法，同时还提供了newCondition()方法来产生用于线程之间通信的Condition对象；此外，Java 5还提供了信号量机制（semaphore），信号量可以用来限制对某个共享资源进行访问的线程的数量。在对资源进行访问之前，线程必须得到信号量的许可（调用Semaphore对象的acquire()方法）；在完成对资源的访问后，线程必须向信号量归还许可（调用Semaphore对象的release()方法）。

下面的例子演示了100个线程同时向一个银行账户中存入1元钱，在没有使用同步机制情况下的执行情况。

• 银行账户类：

  package chimomo.learning.java.code.multithreading;
  
  /**
   * @author Chimomo
   *
   * 银行账户
   */
  public class Account {
  
      // 账户余额
      private double balance;
  
      /**
       * 存款
       *
       * @param money 存入金额
       */
      public void deposit(double money) {
          double newBalance = balance + money;
          try {
              // 模拟此业务需要一段处理时间
              Thread.sleep(10);
          } catch (InterruptedException ex) {
              ex.printStackTrace();
          }
          balance = newBalance;
      }
  
      /**
       * @return 账户余额
       */
      public double getBalance() {
          return balance;
      }
  
  }
  

• 存款线程类：

  package chimomo.learning.java.code.multithreading;
  
  /**
   * @author Chimomo
   *
   * 存款线程类
   *
   */
  public class DepositThread implements Runnable {
  
      // 存入账户
      private Account account;
  
      // 存入金额
      private double money;
  
      public DepositThread(Account account, double money) {
          this.account = account;
          this.money = money;
      }
  
      @Override
      public void run() {
          account.deposit(money);
      }
  
  }
  

• 测试类：

  package chimomo.learning.java.code.multithreading;
  
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  
  /**
   * @author Chimomo
   */
  public class AccountTest {
  
      public static void main(String[] args) {
          Account account = new Account();
          ExecutorService service = Executors.newFixedThreadPool(100);
  
          for (int i = 1; i <= 100; i++) {
              service.execute(new DepositThread(account, 1));
          }
  
          service.shutdown();
          while (!service.isTerminated()) {
          }
  
          System.out.println("账户余额: " + account.getBalance());
      }
  
  }
  
  // Output:
  /*
  账户余额: 3.0
  
  */
  

在没有使用同步机制的情况下，执行结果通常是显示账户余额在10元以下。出现这种状况的原因是，当一个线程A试图存入1元的时候，另外一个线程B也能够进入存款的方法中，线程B读取到的账户余额仍然是线程A存入1元钱之前的账户余额，因此也是在原来的余额0上面做了加1元的操作，同理线程C也会做类似的事情，所以最后100个线程执行结束时，本来期望账户余额为100元，但实际得到的结果通常是在10元以下（很可能是1元哦）。解决这个问题的办法就是同步，当一个线程对银行账户存钱时，需要将此账户锁定，待其操作完成后才允许其他的线程进行操作，代码有如下几种调整方案：

• 在银行账户的存款（deposit）方法上加上同步（synchronized）关键字

  package chimomo.learning.java.code.multithreading;
  
  /**
   * @author Chimomo
   * <p>
   * 银行账户
   */
  public class Account {
  
      // 账户余额
      private double balance;
  
      /**
       * 存款
       *
       * @param money 存入金额
       */
      public synchronized void deposit(double money) {
          double newBalance = balance + money;
          try {
              // 模拟此业务需要一段处理时间
              Thread.sleep(10);
          } catch (InterruptedException ex) {
              ex.printStackTrace();
          }
          balance = newBalance;
      }
  
      /**
       * @return 账户余额
       */
      public double getBalance() {
          return balance;
      }
  
  }
  

• 在线程调用存款方法时对银行账户进行同步

  package chimomo.learning.java.code.multithreading;
  
  /**
   * @author Chimomo
   * <p>
   * 存款线程类
   */
  public class DepositThread implements Runnable {
  
      // 存入账户
      private Account account;
  
      // 存入金额
      private double money;
  
      public DepositThread(Account account, double money) {
          this.account = account;
          this.money = money;
      }
  
      @Override
      public void run() {
          synchronized (account) {
              account.deposit(money);
          }
      }
  }
  

• 通过Java 5显式的锁机制，为每个银行账户创建一个锁对象，在存款时做加锁和解锁的操作

  package chimomo.learning.java.code.multithreading;
  
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  /**
   * @author Chimomo
   *
   * 银行账户
   */
  public class Account {
  
      private Lock accountLock = new ReentrantLock();
  
      // 账户余额
      private double balance;
  
      /**
       * 存款
       *
       * @param money 存入金额
       */
      public void deposit(double money) {
          accountLock.lock();
          try {
              double newBalance = balance + money;
              try {
                  // 模拟此业务需要一段处理时间
                  Thread.sleep(10);
              } catch (InterruptedException ex) {
                  ex.printStackTrace();
              }
              balance = newBalance;
          } finally {
              accountLock.unlock();
          }
      }
  
      /**
       * @return 账户余额
       */
      public double getBalance() {
          return balance;
      }
  
  }
  

按照上述三种方式对代码进行修改后，重写执行测试代码AccountTest，将看到最终的账户余额为100元。当然也可以使用Semaphore或CountdownLatch来实现同步。