线程同步以及线程调度相关的方法

 

线程同步以及线程调度相关的方法

• 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 元钱，在没有使用同步机制和 使用同步机制情况下的执行情况。
• 银行账户类

import java.io.Serializable;

/**
 * @Auther: luojinxue
 * @Date: 2019/3/12 16:17
 * @Description:银行账户类
 */
public class Account implements Serializable {
    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;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

• 存钱线程类

/**
 * @Auther: luojinxue
 * @Date: 2019/3/12 16:25
 * @Description:存钱线程类
 */
public class AddMoneyThread implements Runnable{
    private  Account account;//存入账户
    private double money;//存入金额
    public AddMoneyThread(Account account,double money){
        this.account=account;
        this.money=money;
    }
    @Override
    public void run() {
        account.deposit(money);
    }
}

• 没有线程同步下测试

/**
 * @Auther: luojinxue
 * @Date: 2019/3/12 16:30
 * @Description:没有同步下的测试
 */
public class NonSyncTest {
    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 AddMoneyThread(account, 1));
        }
        service.shutdown();
        while (!service.isTerminated()) {
        }
        System.out.println("账户余额: " + account.getBalance());
    }
}

测试结果

方法三 

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

• ---

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

• import java.io.Serializable;
  
  /**
   * @Auther: luojinxue
   * @Date: 2019/3/12 16:17
   * @Description:银行账户类
   */
  public class Account implements Serializable {
      private double balance; // 账户余额
      /*
       *存款
       * @param money
       *
       */
      public synchronized void deposit(double money) {//用synchronized关键字修饰方法
          double newBalance = balance + money;
      try {
          Thread.sleep(10); // 模拟此业务需要一段处理时间
           }catch(InterruptedException ex) {
          ex.printStackTrace();
      }
           balance = newBalance;
      }
  
      public double getBalance() {
          return balance;
      }
  
      public void setBalance(double balance) {
          this.balance = balance;
      }
  }
  

   方法二

  /**
   * @Auther: luojinxue
   * @Date: 2019/3/12 16:25
   * @Description:存钱线程类
   */
  public class AddMoneyThread implements Runnable{
      private  Account account;//存入账户
      private double money;//存入金额
      public AddMoneyThread(Account account,double money){
          this.account=account;
          this.money=money;
      }
      @Override
      public void run() {
          synchronized(account){ //在线程调用存款方法时对银行账户进行同步
              account.deposit(money);
          }
      }
  }
  

  用上面的测试类进行测试：

• 

• 通过Java5显示的锁机制，为每个银行账户创建一个锁对象，在存款操作进行加锁和解锁

• import java.io.Serializable;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  /**
   * @Auther: luojinxue
   * @Date: 2019/3/12 16:17
   * @Description:银行账户类
   */
  public class Account implements Serializable {
      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();//解锁
          }
      }
  
      public double getBalance() {
          return balance;
      }
  
      public void setBalance(double balance) {
          this.balance = balance;
      }
  }
  

  测试结果：

•