synchronized 关键字的理解

 1、 要保护这一段代码, 必须将它变为临界区，使用Java提供我们的锁机制(同步监视控制)

2、在同一个服务线程中（不管是不是同一个任务执行体），这里形象比喻Person（线程）上Toilet（临界区），一次且只能有一个人在Toilet里，只要Person不出来（不释放锁），其他人(其他线程)就不能进入。 

3、简单来说就是：两个人不能在一时刻拥有房间的使用权。

4、演示代码如下：

package com.tiger.toilet;

import java.util.concurrent.TimeUnit;
/**
 * 要保护这一段代码, 必须将它变为临界区
 * 使用Java提供我们的锁机制(同步监视控制)
 * 在同一个服务线程中（不管是不是同一个任务执行体），这里形象比喻Person（线程）上Toilet（临界区），
 * 一次且只能有一个人在Toilet里，只要Person不出来（不释放锁），其他人(其他线程)就不能进入。
 * 
 * 简单来说就是：两个人不能在一时刻拥有房间的使用权。
 * @author tiger
 * @Date 2017年7月26日
 */
public class ToiletTest{
  public static void main(String[] args) {

    Toilet tagert = new Toilet();
    Thread th1 = new Thread(tagert,"老王");
    Thread th2 = new Thread(tagert,"小王");
    th1.start();
    th2.start();

    Toilet tagert2 = new Toilet();
    Thread th3 = new Thread(tagert2,"老李");
    th3.start();

    //另外一个执行体
    Hotel hotel = new Hotel();
    Thread th4 = new Thread(hotel,"大王");
    th4.start();
  }
}
/**
 * 将上厕所这件事情变为同步  -- 临界区
 * @author tiger
 * @Date 2017年7月26日
 */
class Toilet implements Runnable{
  String lock = "lock";
  @Override
  public void run() {
    //获取当前线程名字
    String name = Thread.currentThread().getName();
    //定义两把锁，激活两把锁
    if (name.equals("老王")) {
      this.lock = "1";
    }else{
      this.lock = "2";
    }
    //同步锁，可以看为是密码锁，密码随意分配，只要不和其他的相同即可
    synchronized (lock) {
      System.out.println(name+" 持有"+lock+"卡上厕所！");
      for (int i = 0; i < 3; i++) {
        try {
          TimeUnit.SECONDS.sleep(1);
          System.out.println(name+" 在厕所呆了 "+ i+" s");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
      System.out.println(name+" 从厕所出来！");
    }
  }
}

class Hotel implements Runnable{
  String lock = "2";
//  String lock = "3";
  @Override
  public void run() {
    //获取当前线程名字
    String name = Thread.currentThread().getName();
    //同步锁，可以看为是密码锁，密码随意分配，只要不和其他的相同即可
    synchronized (lock) {
      System.out.println(name+" 持有"+lock+"卡上酒店！");
      for (int i = 0; i < 6; i++) {
        try {
          TimeUnit.SECONDS.sleep(1);
          System.out.println(name+" 在酒店呆了 "+ i+" s");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
      System.out.println(name+" 从酒店出来！");
    }
  }
}package com.tiger.toilet.room;

import java.util.concurrent.TimeUnit;
/**
 * 联动上锁（同步监视器），同一对象的不同临界区
 * @author tiger
 * @Date 2017年7月26日
 */
public class ToiletTest01 {
  public static void main(String[] args) {
    Task tagert = new Task();
    //一次只能有一个人在厕所里边,只有等待厕所里边的人出来，另外一个人才能进去。
    Thread th1 = new Thread(tagert,"老王");
    Thread th2 = new Thread(tagert,"小王");
    th1.start();
    th2.start();
  }
}
/**
 * 线程类
 * @author tiger
 * @Date 2017年7月26日
 */
class Task implements Runnable{
  Toilet toilet = new Toilet();
  //钥匙库
  String[] lock = {"锁1","锁2"};
  @Override
  public void run() {
    String name = Thread.currentThread().getName();
    //联动上锁
    if (name.equals("老王")) {
      toilet.room01(lock[0]);
    }else{
      toilet.room02(lock[1]);
    }
  }
}
/**
 * 厕所类
 * @author tiger
 * @Date 2017年7月26日
 */
class Toilet {
  //一号
  public void room01(String lock){
    String name = Thread.currentThread().getName();
    //同步锁，可以看为是密码锁，密码随意分配，只要不和其他的相同即可
    synchronized (lock) {
      System.out.println(name+"持有 "+lock+" 上1号厕所！");
      for (int i = 0; i < 5; i++) {
        try {
          TimeUnit.SECONDS.sleep(1);
          System.out.println(name+"在厕所呆了"+ i+"s");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
      System.out.println(name+"从厕所出来！");
    }
  }
  //二号
  public void room02(String lock){
    String name = Thread.currentThread().getName();
    //同步锁，可以看为是密码锁，密码随意分配，只要不和其他的相同即可
    synchronized (lock) {
      System.out.println(name+"持有"+lock+"上2号厕所！");
      for (int i = 0; i < 5; i++) {
        try {
          TimeUnit.SECONDS.sleep(1);
          System.out.println(name+"在厕所呆了"+ i+"s");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
      System.out.println(name+"从厕所出来！");
    }
  }
}