【Java多线程与并发库】03 传统线程互斥技术 synchronized

【Java多线程与并发库】03 传统线程互斥技术 synchronized

我们会使用模拟打印机的程序来说明线程的互斥技术，如下。

打印机出了问题

现在我们写一个模拟打印机打印文本的程序。
打印机的打印方法接收到一个字符串，它会依次打印字符串中的每一个字符。
程序如下：

/**
 * 模拟打印机
 */
class Outputer{
    public void output(String content){
        for(int i = 0; i < content.length(); i ++){
            System.out.print(content.charAt(i));
        }
        System.out.println();
    }
}

之后，我们启动两个线程类执行打印任务，这两个线程共享同一个打印机。
其中第一个线程不停地打印”llllllll”，第二个线程不停地打印”oooooooo”，我们期望两者各自工作，互不干扰。

private void init(){
      Outputer outputer = new Outputer();  // 两个线程共享同一个打印机
      new Thread(new Runnable() {
          @Override
          public void run() {
              while(true) {
                  outputer.output("llllllll");
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
      }).start();

      new Thread(new Runnable() {
          @Override
          public void run() {
              while(true) {
                  outputer.output("oooooooo");
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
      }).start();
  }

两个线程共享同一个打印机执行任务的结果如下：

llllllll
oooooooo
ooollllllll
ooooo
llllllooooooll
oo
lllllloooooooo
ll
ooolllooooo
lllll
llllllll
oooooooo

可见，出现了我们不期望的结果，一个字符串没有打印完就开始打印另外一个字符串了。
为什么会出现这种“不正确”的情况？
因为是线程调度的不确定性。
当一个线程还没有完成当前打印任务时，它的时间片被用完了，那么就会执行另一个线程，所以就出现了上面的不期望的情况。

怎么才能保证一个线程在执行打印任务时，不被其他的线程干扰呢？

……

是不是满足下面这个情况就可以呢？
当一个线程在执行打印任务（打印任务没有结束）时，其他线程就不能够再执行打印任务。
是的。

那怎么做才可以达到这个目的呢？
这就要用到线程的互斥技术，Java提供了synchronized关键字来达到线程互斥目的。
这里我们仅仅讨论synchronized关键字的作用和用法，关于它的原理，可以参看其他文章。

synchronized 关键字

synchronized，字面意思是：同步的，同步化的。

为了解决上面的问题，Java多线程引入了同步监视器。使用同步监视器的通用方法就是同步代码块，同步代码块的语法格式如下：

synchronized(obj){
  // 此处是同步的代码
}

上面语法格式中的 obj 就是同步监视器。
同步代码块的含义是：

线程开始执行同步带块之前，必须先获得同步监视器的锁定。

同步代码块执行结束后，同步监视器会被自动地释放。

同步监视器的目的是，阻止两个线程对同一个共享资源进行并发访问，因此通常使用可能被并发访问的资源充当同步监视器。
此处，打印机是并发访问的资源。

当使用synchronized修饰一个方法时， 同步监视器是 this，也即是调用当前方法的对象，不再需要指明同步监视器对象。

更直白的解释是：
当使用synchronized修饰一个方法或者代码块时，这部分代码就变成为同步的，它不会同时被两个线程同时执行。
也就是，当一个线程正在执行该代码时，其他的线程也要执行这部分代码时，synchronized会将第二个线程阻止在外，当第一个线程执行结束后，才会让第二个线程执行。

由此，我们可以完善之前的打印机的打印方法，public synchronized void outputSafely(String content)如下：

/**
 * 模拟打印机
 */
class Outputer{
    public void output(String content){
        for(int i = 0; i < content.length(); i ++){
            System.out.print(content.charAt(i));
        }
        System.out.println();
    }

    public synchronized void outputSafely(String content){
        for(int i = 0; i < content.length(); i ++){
            System.out.print(content.charAt(i));
        }
        System.out.println();
    }
}

此时的执行结果如下

llllllll
oooooooo
oooooooo
llllllll
oooooooo
llllllll
oooooooo
llllllll
oooooooo
llllllll
oooooooo
llllllll
llllllll
oooooooo

这就是我们期望的打印机执行的结果。

释放同步监视器的锁定

任何线程进入同步代码块、同步方法之前，必须先获得对同步监视器的锁定，那么何时会释放对同步监视器的锁定呢？
程序无法显示释放对同步监视器的锁定。
线程会在如下几种情况下释放对同步监视器的锁定。

• 当前线程的同步方法、同步代码块执行结束，当前线程会释放同步监视器。
• 当前线程在同步方法、同步代码块中出现了未处理的Error或Exception，导致了该方法、代码块异常结束时，当前线程将会释放同步监视器。
• 当前线程在同步方法、同步代码块中调用了同步监视器对象的 wait()方法，则当前线程暂停，并释放同步监视器。

当前线程在同步方法、同步代码块中调用了Thread.sleep() 或者 Thread.yield()方法暂停当前线程的执行，当前线程不会释放同步监视器。

附本文章中的完整程序

/**
 * description:
 *
 * @author liyazhou
 * @since 2017-08-14 14:31
 */
public class TraditionalThreadSynchronized {

    /**
     * 模拟打印机
     */
    class Outputer{
        public void output(String content){
            for(int i = 0; i < content.length(); i ++){
                System.out.print(content.charAt(i));
            }
            System.out.println();
        }
    }

    private void init(){
        Outputer outputer = new Outputer();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    outputer.output("llllllll");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    outputer.output("oooooooo");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    public static void main(String[] args){
        new TraditionalThreadSynchronized().init();
    }
}

参考

《Java多线程与并发库高级应用》
《疯狂Java讲义》