JUC简介

在 Java 5.0 提供了 java.util.concurrent (简称JUC )包，在此包中增加了在并发编程中很常用 的实用工具类，用于定义类似于线程的自定义子 系统，包括线程池、异步 IO 和轻量级任务框架。 提供可调的、灵活的线程池。还提供了设计用于 多线程上下文中的 Collection 实现等。

volatile 关键字

内存可见性

  1. 内存可见性(Memory Visibility)是指当某个线程正在使用对象状态 而另一个线程在同时修改该状态，需要确保当一个线程修改了对象 状态后，其他线程能够看到发生的状态变化。
  2. 可见性错误是指当读操作与写操作在不同的线程中执行时，我们无 法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚 至是根本不可能的事情。
  3. 我们可以通过同步来保证对象被安全地发布。除此之外我们也可以 使用一种更加轻量级的 volatile 变量。

volatile 关键字
Java 提供了一种稍弱的同步机制，即 volatile 变量，用来确保将变量的更新操作通知到其他线程。 可以将 volatile 看做一个轻量级的锁，但是又与 锁有些不同。
不同之处在于：

  • 对于多线程，不是一种互斥关系
  • 不能保证变量状态的“原子性操作”

volatile 关键字不能保证“原子性操作”的代码示例

  1. /*
  2.  * 一、volatile 关键字：当多个线程进行操作共享数据时，可以保证内存中的数据可见。
  3.  *                   相较于 synchronized 是一种较为轻量级的同步策略。
  4.  * 
  5.  * 注意：
  6.  * 1. volatile 不具备“互斥性”
  7.  * 2. volatile 不能保证变量的“原子性”
  8.  */
  9. public class TestVolatile {
  11.    public static void main(String[] args) {
  12.       ThreadDemo td = new ThreadDemo();
  13.       new Thread(td).start();
  15.       // 自循环，直到获取了flag的值跳出循环，如果不用自循环，以下程序已经执行但是还没有从内存中获取的flag值，因为volatile不能保证变量的"原子性"
  16.       while(true){
  17.          if(td.isFlag()){
  18.             System.out.println("------------------");
  19.             break;
  20.          }
  21.       }
  23.    }
  25. }
  27. class ThreadDemo implements Runnable {
  29.    private volatile boolean flag = false;
  31.    @Override
  32.    public void run() {
  34.       try {
  35.          Thread.sleep(200);
  36.       } catch (InterruptedException e) {
  37.       }
  39.       flag = true;
  41.       System.out.println("flag=" + isFlag());
  43.    }
  45.    public boolean isFlag() {
  46.       return flag;
  47.    }
  49.    public void setFlag(boolean flag) {
  50.       this.flag = flag;
  51.    }
  53. }

CAS 算法

  1. CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器 操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并 发访问。
  2. CAS 是一种无锁的非阻塞算法的实现。
  3. CAS 包含了 3 个操作数:
  • 需要读写的内存值 V
  • 进行比较的值 A
  • 拟写入的新值 B
  1. 当且仅当 V 的值等于 A 时，CAS 通过原子方式用新值 B 来更新 V 的 值，否则不会执行任何操作。

CAS 模拟算法

  1. /*
  2.  * 模拟 CAS 算法
  3.  */
  4. public class TestCompareAndSwap {
  6.    public static void main(String[] args) {
  7.       final CompareAndSwap cas = new CompareAndSwap();
  9.       for (int i = 0; i < 10; i++) {
  10.          new Thread(new Runnable() {
  12.             @Override
  13.             public void run() {
  14.                int expectedValue = cas.get();
  15.                boolean b = cas.compareAndSet(expectedValue, (int)(Math.random() * 101));
  16.                System.out.println(b);
  17.             }
  18.          }).start();
  19.       }
  21.    }
  23. }
  25. class CompareAndSwap{
  26.    private int value;
  28.    //获取内存值
  29.    public synchronized int get(){
  30.       return value;
  31.    }
  33.    /**
  34.     * 比较
  35.     * @param expectedValue 预期的值
  36.     * @param newValue 新值
  37.     * @return
  38.     */
  39.    public synchronized int compareAndSwap(int expectedValue, int newValue){
  40.       int oldValue = value;
  42.       if(oldValue == expectedValue){
  43.          this.value = newValue;
  44.       }
  46.       return oldValue;
  47.    }
  49.    //设置
  50.    public synchronized boolean compareAndSet(int expectedValue, int newValue){
  51.       return expectedValue == compareAndSwap(expectedValue, newValue);
  52.    }
  53. }

原子变量

  1. 类的小工具包，支持在单个变量上解除锁的线程安全编程。事实上，此包中的类可将 volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。
  2. 类 AtomicBoolean、AtomicInteger、AtomicLong 和 AtomicReference 的实例各自提供对 相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。
  3. AtomicIntegerArray 、 AtomicLongArray 和 AtomicReferenceArray 类进一步扩展了原子操 作，对这些类型的数组提供了支持。这些类在为其数组元素提供 volatile 访问语义方面也引人注目，这对于普通数组来说是不受支持的。
  4. 核心方法:boolean compareAndSet(expectedValue, updateValue)
  5. java.util.concurrent.atomic包下提供了一些原子操作的常用类
  • AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference
  • AtomicIntegerArray、AtomicLongArray
  • AtomicMarkableReference
  • AtomicReferenceArray

  • AtomicStampedReference

    AtomicInteger 示例 ```java import java.util.concurrent.atomic.AtomicInteger;

/*

  • 一、i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”
  • int i = 10;
  • i = i++; //10
  • int temp = i;
  • i = i + 1;
  • i = temp;
  • 二、原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。
    1. volatile 保证内存可见性
    1. CAS（Compare-And-Swap） 算法保证数据变量的原子性
  • CAS 算法是硬件对于并发操作的支持
  • CAS 包含了三个操作数：
  • ①内存值 V
  • ②预估值 A
  • ③更新值 B

  • 当且仅当 V == A 时， V = B; 否则，不会执行任何操作。 */ public class TestAtomicDemo {

    public static void main(String[] args) { AtomicDemo ad = new AtomicDemo();

    for (int i = 0; i < 10; i++) { new Thread(ad).start(); } }

}

class AtomicDemo implements Runnable{

// private volatile int serialNumber = 0;

private AtomicInteger serialNumber = new AtomicInteger(0);

@Override public void run() {

  1.   try {
  2.      Thread.sleep(200);
  3.   } catch (InterruptedException e) {
  4.   }
  6.   System.out.println(getSerialNumber());

}

public int getSerialNumber(){ return serialNumber.getAndIncrement(); } }

  1. <a name="Wqobq"></a>
  2. # ConcurrentHashMap 锁分段机制
  4. 1. Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器 的性能。
  5. 1. ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对 与多线程的操作，介于 HashMap 与 Hashtable 之间。内部采用“锁分段” 机制替代 Hashtable 的独占锁。进而提高性能。
  6. 1. 此包还提供了设计用于多线程上下文中的 Collection 实现: ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、 CopyOnWriteArrayList 和 CopyOnWriteArraySet。当期望许多线程访问一个给定collection时，ConcurrentHashMap 通常优于同步的 HashMap， ConcurrentSkipListMap 通常优于同步的 TreeMap。当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList 优于同步的 ArrayList。
  7. ```java
  8. import java.util.Iterator;
  9. import java.util.concurrent.CopyOnWriteArrayList;
  11. /*
  12.  * CopyOnWriteArrayList/CopyOnWriteArraySet : “写入并复制”
  13.  * 注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择。
  14.  */
  15. public class TestCopyOnWriteArrayList {
  17.    public static void main(String[] args) {
  18.       HelloThread ht = new HelloThread();
  20.       for (int i = 0; i < 10; i++) {
  21.          new Thread(ht).start();
  22.       }
  23.    }
  25. }
  27. class HelloThread implements Runnable{
  29. // private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
  31.    private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
  33.    static{
  34.       list.add("AA");
  35.       list.add("BB");
  36.       list.add("CC");
  37.    }
  39.    @Override
  40.    public void run() {
  42.       Iterator<String> it = list.iterator();
  44.       while(it.hasNext()){
  45.          System.out.println(it.next());
  47.          list.add("AA");
  48.       }
  50.    }
  52. }

CountDownLatch 闭锁

  1. Java 5.0 在 java.util.concurrent 包中提供了多种并发容器类来改进同步容器 的性能。
  2. CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
  3. 闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行
  • 确保某个计算在其需要的所有资源都被初始化之后才继续执行
  • 确保某个服务在其依赖的所有其他服务都已经启动之后才启动
  • 等待直到某个操作所有参与者都准备就绪再继续执行

示例

  1. import java.util.concurrent.CountDownLatch;
  3. /*
  4.  * CountDownLatch ：闭锁，在完成某些运算时，只有其他所有线程的运算全部完成，当前运算才继续执行
  5.  */
  6. public class TestCountDownLatch {
  8.    public static void main(String[] args) {
  9.       final CountDownLatch latch = new CountDownLatch(50);
  10.       LatchDemo ld = new LatchDemo(latch);
  12.       long start = System.currentTimeMillis();
  14.       for (int i = 0; i < 50; i++) {
  15.          new Thread(ld).start();
  16.       }
  18.       try {
  19.           // 等待其他线程执行完成
  20.          latch.await();
  21.       } catch (InterruptedException e) {
  22.       }
  24.       long end = System.currentTimeMillis();
  26.       System.out.println("耗费时间为：" + (end - start));
  27.    }
  29. }
  31. class LatchDemo implements Runnable {
  33.    private CountDownLatch latch;
  35.    public LatchDemo(CountDownLatch latch) {
  36.       this.latch = latch;
  37.    }
  39.    @Override
  40.    public void run() {
  42.       try {
  43.          for (int i = 0; i < 50000; i++) {
  44.             if (i % 2 == 0) {
  45.                System.out.println(i);
  46.             }
  47.          }
  48.       } finally {
  49.          latch.countDown();
  50.       }
  52.    }
  54. }

Callable 接口

  1. Java 5.0 在 java.util.concurrent 提供了一个新的创建执行线程的方式：Callable 接口
  2. Callable 接口类似于 Runnable，两者的区别是Runnable不会返回结果，并且无法抛出经过检查的异常，而Callable接口有返回结果。
  3. Callable 需要依赖FutureTask ，FutureTask 也可以用作闭锁。

实现Callable接口执行线程获取返回值代码示例

  1. import java.util.concurrent.Callable;
  2. import java.util.concurrent.ExecutionException;
  3. import java.util.concurrent.FutureTask;
  5. /*
  6.  * 一、创建执行线程的方式三：实现 Callable 接口。 相较于实现 Runnable 接口的方式，方法可以有返回值，并且可以抛出异常。
  7.  * 
  8.  * 二、执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。  FutureTask 是  Future 接口的实现类
  9.  */
  10. public class TestCallable {
  12.    public static void main(String[] args) {
  13.       ThreadDemo td = new ThreadDemo();
  15.       //1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
  16.       FutureTask<Integer> result = new FutureTask<>(td);
  18.       new Thread(result).start();
  20.       //2.接收线程运算后的结果
  21.       try {
  22.          //FutureTask 可用于闭锁，在这里等待线程的执行结果，才会执行后面的语句
  23.          Integer sum = result.get();  
  24.          System.out.println(sum);
  25.          System.out.println("------------------------------------");
  26.       } catch (InterruptedException | ExecutionException e) {
  27.          e.printStackTrace();
  28.       }
  29.    }
  30. }
  32. class ThreadDemo implements Callable<Integer>{
  34.    @Override
  35.    public Integer call() throws Exception {
  36.       int sum = 0;
  38.       for (int i = 0; i <= 100000; i++) {
  39.          sum += i;
  40.       }
  42.       return sum;
  43.    }
  45. }
  47. /*class ThreadDemo implements Runnable{
  49.    @Override
  50.    public void run() {
  51.    }
  53. }*/

Lock 同步锁

  1. 在 Java 5.0 之前，协调共享对象的访问时可以使用的机制只有 synchronized 和 volatile 。Java 5.0 后增加了一些新的机制，但并不是一种替代内置锁的方法，而是当内置锁不适用时，作为一种可选择的高级功能。
  2. ReentrantLock 实现了Lock接口，并提供了与 synchronized 相同的互斥性和内存可见性。但相较于 synchronized 提供了更高的处理锁的灵活性。

多线程使用Lock 来实现变量的递减示例：

  1. import java.util.concurrent.locks.Lock;
  2. import java.util.concurrent.locks.ReentrantLock;
  4. /*
  5.  * 一、用于解决多线程安全问题的方式：
  6.  * 
  7.  * synchronized:隐式锁
  8.  * 1. 同步代码块
  9.  * 2. 同步方法
  10.  * 
  11.  * jdk 1.5 后：
  12.  * 3. 同步锁 Lock
  13.  * 注意：是一个显示锁，需要通过 lock() 方法上锁，必须通过 unlock() 方法进行释放锁
  14.  */
  15. public class TestLock {
  17.    public static void main(String[] args) {
  18.       Ticket ticket = new Ticket();
  20.       new Thread(ticket, "1号窗口").start();
  21.       new Thread(ticket, "2号窗口").start();
  22.       new Thread(ticket, "3号窗口").start();
  23.    }
  25. }
  27. class Ticket implements Runnable{
  29.    private int tick = 100;
  31.    private Lock lock = new ReentrantLock();
  33.    @Override
  34.    public void run() {
  35.       while(true){
  37.          lock.lock(); //上锁
  39.          try{
  40.             if(tick > 0){
  41.                try {
  42.                   Thread.sleep(200);
  43.                } catch (InterruptedException e) {
  44.                }
  46.                System.out.println(Thread.currentThread().getName() + " 完成售票，余票为：" + --tick);
  47.             }
  48.          }finally{
  49.             lock.unlock(); //释放锁
  50.          }
  51.       }
  52.    }
  54. }

Condition 控制线程通信

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

多线程下使用Condition 顺序打印线程名称示例：

  1. import java.util.concurrent.locks.Condition;
  2. import java.util.concurrent.locks.Lock;
  3. import java.util.concurrent.locks.ReentrantLock;
  5. /*
  6.  * 编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。
  7.  * 如：ABCABCABC…… 依次递归
  8.  */
  9. public class TestABCAlternate {
  11.    public static void main(String[] args) {
  12.       AlternateDemo ad = new AlternateDemo();
  14.       new Thread(new Runnable() {
  15.          @Override
  16.          public void run() {
  18.             for (int i = 1; i <= 20; i++) {
  19.                ad.loopA(i);
  20.             }
  22.          }
  23.       }, "A").start();
  25.       new Thread(new Runnable() {
  26.          @Override
  27.          public void run() {
  29.             for (int i = 1; i <= 20; i++) {
  30.                ad.loopB(i);
  31.             }
  33.          }
  34.       }, "B").start();
  36.       new Thread(new Runnable() {
  37.          @Override
  38.          public void run() {
  40.             for (int i = 1; i <= 20; i++) {
  41.                ad.loopC(i);
  43.                System.out.println("-----------------------------------");
  44.             }
  46.          }
  47.       }, "C").start();
  48.    }
  50. }
  52. class AlternateDemo{
  54.    private int number = 1; //当前正在执行线程的标记
  56.    private Lock lock = new ReentrantLock();
  57.    private Condition condition1 = lock.newCondition();
  58.    private Condition condition2 = lock.newCondition();
  59.    private Condition condition3 = lock.newCondition();
  61.    /**
  62.     * @param totalLoop : 循环第几轮
  63.     */
  64.    public void loopA(int totalLoop){
  65.       lock.lock();
  67.       try {
  68.          //1. 判断
  69.          if(number != 1){
  70.             condition1.await();
  71.          }
  73.          //2. 打印
  74.          for (int i = 1; i <= 1; i++) {
  75.             System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
  76.          }
  78.          //3. 唤醒
  79.          number = 2;
  80.          condition2.signal();
  81.       } catch (Exception e) {
  82.          e.printStackTrace();
  83.       } finally {
  84.          lock.unlock();
  85.       }
  86.    }
  88.    public void loopB(int totalLoop){
  89.       lock.lock();
  91.       try {
  92.          //1. 判断
  93.          if(number != 2){
  94.             condition2.await();
  95.          }
  97.          //2. 打印
  98.          for (int i = 1; i <= 1; i++) {
  99.             System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
  100.          }
  102.          //3. 唤醒
  103.          number = 3;
  104.          condition3.signal();
  105.       } catch (Exception e) {
  106.          e.printStackTrace();
  107.       } finally {
  108.          lock.unlock();
  109.       }
  110.    }
  112.    public void loopC(int totalLoop){
  113.       lock.lock();
  115.       try {
  116.          //1. 判断
  117.          if(number != 3){
  118.             condition3.await();
  119.          }
  121.          //2. 打印
  122.          for (int i = 1; i <= 1; i++) {
  123.             System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
  124.          }
  126.          //3. 唤醒
  127.          number = 1;
  128.          condition1.signal();
  129.       } catch (Exception e) {
  130.          e.printStackTrace();
  131.       } finally {
  132.          lock.unlock();
  133.       }
  134.    }
  136. }

ReadWriteLock 读写锁

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

一个线程写、多个线程读的代码示例：

  1. import java.util.concurrent.locks.ReadWriteLock;
  2. import java.util.concurrent.locks.ReentrantReadWriteLock;
  4. /*
  5.  * 1. ReadWriteLock : 读写锁
  6.  * 
  7.  * 写写/读写 需要“互斥”
  8.  * 读读 不需要互斥
  9.  * 
  10.  */
  11. public class TestReadWriteLock {
  13.    public static void main(String[] args) {
  14.       ReadWriteLockDemo rw = new ReadWriteLockDemo();
  16.       new Thread(new Runnable() {
  18.          @Override
  19.          public void run() {
  20.             rw.set((int)(Math.random() * 101));
  21.          }
  22.       }, "Write:").start();
  25.       for (int i = 0; i < 100; i++) {
  26.          new Thread(new Runnable() {
  28.             @Override
  29.             public void run() {
  30.                rw.get();
  31.             }
  32.          }).start();
  33.       }
  34.    }
  36. }
  38. class ReadWriteLockDemo{
  40.    private int number = 0;
  42.    private ReadWriteLock lock = new ReentrantReadWriteLock();
  44.    //读
  45.    public void get(){
  46.       lock.readLock().lock(); //上锁
  47.       try{
  48.          System.out.println(Thread.currentThread().getName() + " : " + number);
  49.       }finally{
  50.          lock.readLock().unlock(); //释放锁
  51.       }
  52.    }
  54.    //写
  55.    public void set(int number){
  56.       lock.writeLock().lock();
  57.       try{
  58.          System.out.println(Thread.currentThread().getName());
  59.          this.number = number;
  60.       }finally{
  61.          lock.writeLock().unlock();
  62.       }
  63.    }
  64. }

线程八锁

  1. 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用 其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻 内，只能有唯一一个线程去访问这些synchronized方法
  2. 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的 synchronized方法
  3. 普通方法和同步锁无关
  4. 换成两个对象后，不是同一把锁了，情况立刻变化
  5. 一个类中的静态方法和普通方法加synchronized关键字互不影响，普通方法的锁是当前this对象，静态方法的锁是当前类
  6. 所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
  7. 所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个 静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象!

线程八所的代码示例：

  1. /*
  2.  * 题目：判断打印的 "one" or "two" ？
  3.  * 
  4.  * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one  two
  5.  * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one  two
  6.  * 3. 新增普通方法 getThree() , 打印? //three  one   two
  7.  * 4. 两个普通同步方法，两个 Number 对象，打印?  //two  one
  8.  * 5. 修改 getOne() 为静态同步方法，打印?  //two   one
  9.  * 6. 修改两个方法均为静态同步方法，一个 Number 对象?  //one   two
  10.  * 7. 一个静态同步方法，一个非静态同步方法，两个 Number 对象?  //two  one
  11.  * 8. 两个静态同步方法，两个 Number 对象?   //one  two
  12.  * 
  13.  * 线程八锁的关键：
  14.  * ①非静态方法的锁默认为  this,  静态方法的锁为 对应的 Class 实例
  15.  * ②某一个时刻内，只能有一个线程持有锁，无论几个方法。
  16.  */
  17. public class TestThread8Monitor {
  19.    public static void main(String[] args) {
  20.       Number number = new Number();
  21.       Number number2 = new Number();
  23.       new Thread(new Runnable() {
  24.          @Override
  25.          public void run() {
  26.             number.getOne();
  27.          } 
  28.       }).start();
  30.       new Thread(new Runnable() {
  31.          @Override
  32.          public void run() {
  33. //          number.getTwo();
  34.             number2.getTwo();
  35.          }
  36.       }).start();
  38.       /*new Thread(new Runnable() {
  39.          @Override
  40.          public void run() {
  41.             number.getThree();
  42.          }
  43.       }).start();*/
  45.    }
  47. }
  49. class Number{
  51.    public static synchronized void getOne(){//Number.class
  52.       try {
  53.          Thread.sleep(3000);
  54.       } catch (InterruptedException e) {
  55.       }
  57.       System.out.println("one");
  58.    }
  60.    public synchronized void getTwo(){//this
  61.       System.out.println("two");
  62.    }
  64.    public void getThree(){
  65.       System.out.println("three");
  66.    }
  68. }