文章目录

• Java多线程编程入门
• • 1. 多线程编程基础
  • • 1.1 进程、线程
    • 1.2 使用多线程
    • 1.3 线程常用API
    • 1.4 停止线程
    • 1.5 暂停线程
    • 1.6 yield方法
    • 1.7 线程的优先级
    • 1.8 守护线程
  • 1. 线程的同步机制
  • • 2.1 synchronized同步方法
    • 2.2 synchronized同步语句块
    • 2.3 volatile关键字
  • 1. 线程间的通信
  • • 3.1 wait与notify
    • 3.2 join方法
    • 3.3 ThreadLocal类
  • 1. Lock
  • • 4.1 ReentranLock
    • 4.2 ReentrantReadWriteLock
  • 1. 拾遗增补
  • • 5.1 线程的状态
    • 5.2 Callable接口
    • 5.3 线程池

Java多线程编程入门

1. 多线程编程基础

1.1 进程、线程

1.1.1 进程

狭义：进程是正在运行的程序的实例。

广义：进程是一个具有一定独立功能的程序，关于某个数据集合的一次运行活动。

进程是操作系统动态执行的基本单元，在传统的操作系统中， 进程即是基本的分配单元，也是基本的执行单元。

1.1.2 线程

线程是操作系统能够进行运算调试的最小单位。它被包含在进程中，是进程中的实际动作单位。一个线程指的是进程中的一个单一顺序的控制流，一个进程中可以并发多个线程，每个线程执行不同的任务。

1.1.3 多线程的优点

1. 可以把占据时间较长的任务放到后台去处理
2. 程序的运行速度加快

1.2 使用多线程

1.2.1 继承Thread

步骤：

1. 创建一个类，这个类需要继承Thread
2. 重写Thread类的run方法（业务代码）
3. 实例化创建好的线程类

4. 调用实例化对象的start方法启动线程

   package chap1;

   public class Demo02 {

   public static void main(String[] args) {
       Thread t = new Demo02Thread();
       t.start();  // 启动线程
       System.out.println("运行了main方法");
   }

   }

   class Demo02Thread extends Thread{

   @Override
   public void run() {
       System.out.println("运行了run方法");
   }

   }

线程运行具有以下特点

1. 随机性

   package chap1;

   public class Demo03 {

   public static void main(String[] args) {
       Thread t = new Demo03Thread();
       t.start();
       try {
           for (int i = 0; i < 10; i++) {
               System.out.println("运行main方法");
               Thread.sleep(100);
           }
       }catch (InterruptedException e){
           e.printStackTrace();
       }
   }

   }

   class Demo03Thread extends Thread{

   @Override
   public void run() {
       try {
           for (int i = 0; i < 10; i++) {
               System.out.println("运行run方法");
               Thread.sleep(100);
           }
       }catch (InterruptedException e){
           e.printStackTrace();
       }
   }

   }

在多线程编程中，代码的执行结果与代码的执行顺序或调用顺序是无关的。线程是一个子任务，CPU以不确定的方式或者是以随机的时间来调用线程中的run方法。

如果直接调用线程对象的run方法，不是启动线程，而是由main主线程来调用run方法。

1. start的执行顺序与线程的启动顺序不一致

   package chap1;

   public class Demo04 {

   public static void main(String[] args) {
       Thread t1 = new Demo04Thread(1);
       Thread t2 = new Demo04Thread(2);
       Thread t3 = new Demo04Thread(3);
       Thread t4 = new Demo04Thread(4);
       Thread t5 = new Demo04Thread(5);
       t1.start();
       t2.start();
       t3.start();
       t4.start();
       t5.start();
   }

   }

   class Demo04Thread extends Thread{

   private int val;
   public Demo04Thread(int val){
       this.val = val;
   }
   @Override
   public void run() {
       System.out.println("val=" + val);
   }

   }

1.2.2 实现Runnable接口

步骤：

1. 创建一个类，这个类需要实现Runnable接口
2. 重写Runnable接口的run方法
3. 实例化创建的这个类
4. 实例化一个Thread对象，并把第3步创建的对象通过Thread的构造方法进行传递

5. 调用Thread对象的start方法

   package chap1;

   public class Demo05 {

   public static void main(String[] args) {
       Runnable r = new Demo05Thread();
       Thread t = new Thread(r);
       t.start();
       System.out.println("运行了main方法");
   }

   }

   class Demo05Thread implements Runnable{

   @Override
   public void run() {
       System.out.println("运行了run方法");
   }

   }

使用Thread继承的方式开发多线程应用程序是有局限的，Java是单继承，为了改变这种限抽，可以使用Runnable接口方式来实现多线程。

1.2.3 成员变量与线程安全

自定义线程类中的成员变量针对其它线程可以分为共享与不共享，这个多线程之间交互时很重要的一个技术点

1. 不共享数据

   package chap1;

   public class Demo06 {

   public static void main(String[] args) {
       Thread t1 = new Demo06Thread();
       Thread t2 = new Demo06Thread();
       Thread t3 = new Demo06Thread();
       t1.start();
       t2.start();
       t3.start();
   }

   }

   class Demo06Thread extends Thread{

   private int count = 5;
   @Override
   public void run() {
       while(count > 0) {
           count--;
           System.out.println(Thread.currentThread().getName() + ": count=" + count);
       }
   }

   }

每个线程都有各自的count变量，自己减少自己的count变量的值，这种情况就是不共享

1. 共享数据

   package chap1;

   public class Demo07 {

   public static void main(String[] args) {
       Thread t = new Demo07Thread();
       Thread t1 = new Thread(t);
       Thread t2 = new Thread(t);
       Thread t3 = new Thread(t);
       Thread t4 = new Thread(t);
       Thread t5 = new Thread(t);
       t1.start();
       t2.start();
       t3.start();
       t4.start();
       t5.start();
   }

   }

   class Demo07Thread extends Thread {

   private int count = 5;
   @Override
   public void run() {
       count--;
       System.out.println(Thread.currentThread().getName() + ", count=" + count);
   }

   }

共享数据有概率出现不同线程使用相同的count的值，产生了『非线程安全问题』。

1.3 线程常用API

1.3.1 currentThread方法

返回代码正在那个线程调用的详细信息

package chap1;
public class Demo08 {
    public static void main(String[] args) {
        Thread t = new Demo08Thread();
        t.start();
        System.out.println("main方法：" + Thread.currentThread().getName());
    }
}
class Demo08Thread extends Thread{
    public Demo08Thread(){
        System.out.println("构造方法：" + Thread.currentThread().getName());
    }
    @Override
    public void run() {
        System.out.println("run方法" + Thread.currentThread().getName());
    }
}

main方法被命名为main的线程调用，线程类的构造方法是被main线程调用，run方法是被Thread-0的线程调用，run方法是自动被调用的方法。

1.3.2 isAlive

是判断当前的线程是否处于活动状态

package chap1;
public class Demo09 {
    public static void main(String[] args) {
        Thread t = new Demo09Thread();
        System.out.println("准备开始启动线程：" + t.isAlive());
        t.start();  // 启动线程
        System.out.println("启动线程后：" + t.isAlive());
    }
}
class Demo09Thread extends Thread{
    @Override
    public void run() {
        System.out.println("run方法运行状态：" + this.isAlive());
    }
}

活动状态就是线程已经启动且运行没有结束。线程处于正在运行或准备开始运行的状态，就认为线程是『存活』的状态。

1.3.3 sleep方法

作用是在指定的毫秒数内让当前『正在执行的线程』暂停执行。

package chap1;
import java.sql.SQLOutput;
public class Demo10 {
    public static void main(String[] args) {
        Thread t = new Demo10Thread();
        System.out.println("开始于" + System.currentTimeMillis());
        t.start();
        System.out.println("结束于" + System.currentTimeMillis());
    }
}
class Demo10Thread extends Thread{
    @Override
    public void run() {
        try {
            System.out.println("线程开始于" + System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("线程结束于" + System.currentTimeMillis());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

1.3.4 getId方法

作用获取当前线程的唯一标识

package chap1;
public class Demo11 {
    public static void main(String[] args) {
        Thread t = Thread.currentThread();
        System.out.println(t.getName() + ", " + t.getId());
    }
}

1.4 停止线程

停止一个线程意味着在线程处理完成任务之前结束正在执行的操作。

1. 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

   package chap1;

   public class Demo12 {

   public static void main(String[] args) throws InterruptedException {
       Demo12Thread t = new Demo12Thread();
       t.start();
       Thread.sleep(2000);
       t.stopThread();
   }

   }

   class Demo12Thread extends Thread{

   private boolean flag = true;
   @Override
   public void run() {
       try {
           while (flag) {
               System.out.println("time=" + System.currentTimeMillis());
               Thread.sleep(1000);
           }
           System.out.println("线程执行结束");
       }catch(InterruptedException e){
           e.printStackTrace();
       }
   }
   public void stopThread(){
       flag = false;
   }

   }

2. stop方法强制结束线程

   package chap1;

   public class Demo13 {

   public static void main(String[] args) throws InterruptedException {
       Thread t = new Demo13Thread();
       t.start();
       Thread.sleep(2000);
       t.stop();
   }

   }

   class Demo13Thread extends Thread{

   @Override
   public void run() {
       try {
           while (true) {
               System.out.println("time=" + System.currentTimeMillis());
               Thread.sleep(1000);
           }
       }catch (InterruptedException e){
           e.printStackTrace();
       }catch (ThreadDeath e){
           System.out.println("进入catch块");
           e.printStackTrace();
       }
   }

   }

stop方法已经被作废，如果强制让线程停止有可能使一些清理性的工作得不到完成。另外一个原因是对锁定的对象进行『解锁』，导致数据得不同同步的处理，出现数据不一致性的问题。

package chap1;
public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Demo14User user = new Demo14User();
        Thread t = new Demo14Thread(user);
        t.start();
        Thread.sleep(500);
        t.stop();
        System.out.println("username=" + user.getUsername() + ", password=" + user.getPassword());
    }
}
class Demo14Thread extends Thread{
    private Demo14User user;
    public Demo14Thread(Demo14User user){
        this.user = user;
    }
    @Override
    public void run() {
        user.updateUsernameAndPassword("b", "bb");
    }
}
class Demo14User {
    private String username = "a";
    private String password = "aa";
    public void setUsername(String username){
        this.username = username;
    }
    public String getUsername(){
        return username;
    }
    public void setPassword(String passpword){
        this.password = passpword;
    }
    public String getPassword(){
        return password;
    }
    synchronized public void updateUsernameAndPassword(String username, String password){
        try {
            this.username = username;
            Thread.sleep(10000);
            this.password = password;
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

1. 使用interrupt方法中断线程

   package chap1;

   public class Demo15 {

   public static void main(String[] args) {
       Thread t = new Demo15Thread();
       t.start();
       t.interrupt();
   }

   }

   class Demo15Thread extends Thread{

   @Override
   public void run() {
       for (int i = 0; i < 10000; i++) {
           System.out.println("i=" + i);
       }
   }

   }

调用interrupt方法不会真正的结束线程，在当前线程中打上一个停止的标记。

Thread类提供了interrupted方法测试当前线程是否中断，isInterrupted方法测试线程是否已经中断。

package chap1;
public class Demo15 {
    public static void main(String[] args) {
        Thread t = new Demo15Thread();
        t.start();
        t.interrupt();
        System.out.println("是否停止1？" + t.isInterrupted());
        System.out.println("是否停止2？" + Thread.interrupted());
    }
}
class Demo15Thread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("i=" + i);
        }
    }
}

t.isInterrupted方法是检查Demo15Thread是否被打上停止的标记，Thread.interrupted方法是检查主线程是否被打上停止的标记。

package chap1;
public class Demo16 {
    public static void main(String[] args) {
        Thread.currentThread().interrupt();
        System.out.println("是否停止1？" + Thread.interrupted());
        System.out.println("是否停止2？" + Thread.interrupted());
    }
}

测试当前线程是否已经中断，线程的中断状态由方法清除。如果 连接两次调用该方法，第二次调用将返回false。

package chap1;
public class Demo17 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Demo17Thread();
        t.start();
//        Thread.sleep(10);
        t.interrupt();
    }
}
class Demo17Thread extends Thread{
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10000; i++) {
                if (this.isInterrupted()) {
                    System.out.println("已经是停止状态了！我有退出");
//                break;
                    throw new InterruptedException();
                }
                System.out.println("i=" + i);
            }
            System.out.println("这里是结束循环后的代码");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
package chap1;
public class Demo18 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Demo18Thread();
        t.start();
        Thread.sleep(10);
        t.interrupt();
    }
}
class Demo18Thread extends Thread{
    @Override
    public void run() {
        try {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                String s = new String();
            }
            System.out.println("开始线程");
            Thread.sleep(20000);
            System.out.println("结束线程");
        }catch (InterruptedException e){
            System.out.println("异常进入到catch代码块");
            e.printStackTrace();
        }
    }
}

如果程中有sleep代码，不管是否进入到sleep的状态，如果调用了interrupt方法都会产生异常信息。

1.5 暂停线程

暂停线程使用suspend，重启暂停线程使用resume方法

package chap1;
public class Demo19 {
    public static void main(String[] args) throws InterruptedException {
        Demo19Thread t = new Demo19Thread();
        t.start();
        Thread.sleep(1000);
        t.suspend();    // 暂停线程
        System.out.println("A=" + System.currentTimeMillis() + ", i=" + t.getI());
        Thread.sleep(1000);
        System.out.println("A=" + System.currentTimeMillis() + ", i=" + t.getI());
        t.resume();     // 恢复暂停线程运行
        Thread.sleep(1000);
        t.suspend();
        System.out.println("B=" + System.currentTimeMillis() + ", i=" + t.getI());
        Thread.sleep(1000);
        System.out.println("B=" + System.currentTimeMillis() + ", i=" + t.getI());
    }
}
class Demo19Thread extends Thread{
    private long i = 0;
    public long getI(){
        return i;
    }
    public void setI(long i){
        this.i = i;
    }
    @Override
    public void run() {
        while (true){
            i++;
        }
    }
}

suspend如果独占公共的同步对象，使其它线程无法访问公共同步对象

package chap1;
public class Demo20 {
    public static void main(String[] args) throws InterruptedException {
        Demo20Service service = new Demo20Service();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                service.printString();
            }
        };
        t1.setName("A");    // setName修改线程的名称，这里就是把Thread-0修改为A
        t1.start();
        Thread.sleep(10);
        Thread t2 = new Thread(){
            @Override
            public void run() {
                service.printString();
            }
        };
        t2.start();
    }
}
class Demo20Service {
    synchronized public void printString(){
        System.out.println("线程开始");
        if ("A".equals(Thread.currentThread().getName())){
            System.out.println("A线程永远suspend了");
            Thread.currentThread().suspend();
        }
        System.out.println("线程结束");
    }
}

suspend下println方法不会释放同步锁

package chap1;
public class Demo21 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Demo21Thread();
        t.start();
        Thread.sleep(100);
        t.suspend();
        System.out.println("main结束");
    }
}
class Demo21Thread extends Thread{
    private long i = 0;
    @Override
    public void run() {
        while(true){
            i++;
            System.out.println("i=" + i);
        }
    }
}

程序运行到println方法内部时，同步锁没有被释放，导致当前的PrintStream对象的println方法一直呈『暂停』状态。

suspend会造成共享对象数据不同步

package chap1;
public class Demo22 {
    public static void main(String[] args) throws InterruptedException {
        Demo22User user = new Demo22User();
        Thread t1 = new Thread(){
            @Override
            public void run() {
                user.updateUsernameAndPassword("b", "bb");
            }
        };
        t1.setName("A");
        t1.start();
        Thread.sleep(10);
        Thread t2 = new Thread(){
            @Override
            public void run() {
                user.printUseruserAndPassword();
            }
        };
        t2.start();
    }
}
class Demo22User {
    private String username = "a";
    private String password = "aa";
    public void updateUsernameAndPassword(String username, String password){
        this.username = username;
        if ("A".equals(Thread.currentThread().getName())){
            System.out.println("停止A线程");
            Thread.currentThread().suspend();
        }
        this.password = password;
    }
    public void printUseruserAndPassword(){
        System.out.println("username=" + username + ", password=" +password);
    }
}

1.6 yield方法

yield方法的作用是放弃当前的CPU资源，将资源让给其它的任务去占用CPU执行。但放弃时间不确定，有可能刚刚放弃，马上又获取CPU时间片。

package chap1;
public class Demo23 {
    public static void main(String[] args) {
        Thread t1 = new Demo23Thread();
        t1.start();
    }
}
class Demo23Thread extends Thread{
    @Override
    public void run() {
        int count = 0;
        long start = System.currentTimeMillis();
        for (int i = 0; i < 500000; i++) {
            Thread.yield();
            count  += i + 1;
        }
        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start) + "毫秒");
    }
}

1.7 线程的优先级

在操作系统中，线程可以划分优先级，优先级较高的线程得到更多的CPU资源，也就CPU会优先执行优先级较高的线程对象中的任务。设置线程优先有助于帮助『线程调度器』确定在下一次选择哪个线程优先执行。

设置线程的优先级使用setPriority方法，优级分为1~10个级别，如果设置优先级小于1或大于10，JDK抛出IllegalArgumentException。JDK默认设置3个优先级常量，MIN_PRIORITY=1(最小值)，NORM_PRIORITY=5(中间值，默认)，MAX_PRIORITY=10(最大值)。

获取线程的优先级使用getPriority方法。

package chap1;
public class Demo24 {
    public static void main(String[] args) {
        System.out.println("主线程的运行优先级是：" + Thread.currentThread().getPriority());
        Thread.currentThread().setPriority(1);
        System.out.println("主线程的运行优先级是：" + Thread.currentThread().getPriority());
        Thread t = new Demo24Thread();
        t.start();
    }
}
class Demo24Thread extends Thread{
    @Override
    public void run() {
        System.out.println("线程的运行优先级是：" + this.getPriority());
    }
}

线程的优先级具有继承性，比如线程A启动线程B，线程B的优先级与线程A是一样的。

package chap1;
import java.util.Random;
public class Demo25 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread t1 = new Demo25Thread();
            t1.setName("A" + i);
            t1.setPriority(Thread.MAX_PRIORITY);
            t1.start();
            Thread t2 = new Demo25Thread();
            t2.setName("B" + i);
            t2.setPriority(Thread.MIN_PRIORITY);
            t2.start();
        }
    }
}
class Demo25Thread extends Thread{
    @Override
    public void run() {
        long start = System.currentTimeMillis();
        long count = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 50000; j++) {
                Random r = new Random();
                count += i * j + r.nextInt();;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("线程" + this.getName() + "执行完成使用了" + (end  - start) + "毫秒");
    }
}

高优先级的线程总是大部分先执行完，但不代表高优先级的线程全部执行完。当线程优先级的等级差距很大时，谁先执行完和代码的调用顺序无关。

线程的优先还有『随机性』，也就是说优先级高的线不一定每一次都先执行完成。

1.8 守护线程

在Java线程中有两种线程，一种是用户线程，另一种是守护线程。

守护线程是一种特殊的线程，特殊指的是当进程中不存在用户线程时，守护线程会自动销毁。典型的守护线程的例子就是垃圾回收线程，当进程中没有用户线程，垃圾回收线程就没有存在的必要了，会自动销毁。

package chap1;
public class Demo26 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Demo26Thread();
        t.setDaemon(true);  // 把指定的线程设置为守护线程
        t.start();
        Thread.sleep(3000);
        System.out.println("主线程结束");
    }
}
class Demo26Thread extends Thread{
    @Override
    public void run() {
        try {
            while (true) {
                System.out.println("time=" + System.currentTimeMillis());
                Thread.sleep(1000);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

设置守护线程必须要在调用start方法之前设置，否则JDK会产生IllegalThreadStateException

2. 线程的同步机制

Java多线程中的同步，如何在Java语言中开发出线程安全的程序，如何在Java语文中解决非线程安全所带来的相关问题。

2.1 synchronized同步方法

『线程安全』与『非线程安全』是学习多线程技术时一定会遇到的经典问题。『非线程安全』其实当多个线程访问同一个对象中的成员变量时产生的，产生的后果就是『脏读』，就是取到的数据其实是被更改过的。而『线程安全』就是以获取的成员变量的值是经过同步处理的，不会出现脏读的现象。

1. 局部变量是线程安全的

   package chap2;

   public class Demo01 {

   public static void main(String[] args) {
       Demo01Service service = new Demo01Service();
       Thread t1 = new Demo01ThreadA(service);
       t1.start();
       Thread t2 = new Demo01ThreadB(service);
       t2.start();
   }

   }

   class Demo01Service{

   public void add(String username){
       int num = 0;
       if ("a".equals(username)){
           num = 100;
           System.out.println("a set over");
           // 等待另外一个线程修改num的值
           try {
               Thread.sleep(2000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }else {
           num = 200;
           System.out.println("b set over");
       }
       System.out.println("username=" + username + ", num=" + num);
   }

   }

   class Demo01ThreadA extends Thread{

   private Demo01Service service;
   public Demo01ThreadA(Demo01Service service){
       this.service = service;
   }
   @Override
   public void run() {
       service.add("a");
   }

   }
   class Demo01ThreadB extends Thread{

   private Demo01Service service;
   public Demo01ThreadB(Demo01Service service){
       this.service = service;
   }
   @Override
   public void run() {
       service.add("b");
   }

   }

局部变量不存在非线程安全问题，永远都是线程安全的。这是由局部变量是私有的特征所造成的。

1. 成员变量不是线程安全

   package chap2;

   public class Demo02 {

   public static void main(String[] args) {
       Demo02Service service = new Demo02Service();
       Thread t1 = new Demo02ThreadA(service);
       Thread t2 = new Demo02ThreadB(service);
       t1.start();
       t2.start();
   }

   }

   class Demo02Service {

   private int num;
   synchronized public void add(String username){
       if ("a".equals(username)){
           num = 100;
           System.out.println("a is set");
           try {
               Thread.sleep(2000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }else{
           num = 200;
           System.out.println("b is set");
       }
       System.out.println("username=" + username + ", num=" + num);
   }

   }

   class Demo02ThreadA extends Thread{

   private Demo02Service service;
   public Demo02ThreadA(Demo02Service service){
       this.service = service;
   }
   @Override
   public void run() {
       service.add("a");
   }

   }

   class Demo02ThreadB extends Thread{

   private Demo02Service service;
   public Demo02ThreadB(Demo02Service service){
       this.service = service;
   }
   @Override
   public void run() {
       service.add("b");
   }

   }

如果有两个线程同时操作业务对象中的成员变量，可能会产生『非线程安全』问题，需要在方法前使用关键字synchronized进行修饰。

1. 多个对象使用多个对象锁

   package chap2;

   public class Demo03 {

   public static void main(String[] args) {
       Demo03Service service1 = new Demo03Service();
       Demo03Service service2 = new Demo03Service();
       Thread t1 = new Demo03ThreadA(service1);
       Thread t2 = new Demo03ThreadB(service2);
       t1.start();
       t2.start();
   }

   }

   class Demo03Service {

   private int num;
   synchronized public void add(String username){
       if ("a".equals(username)){
           num = 100;
           System.out.println("a is set");
           try {
               Thread.sleep(2000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }else{
           num = 200;
           System.out.println("b is set");
       }
       System.out.println("username=" + username + ", num=" + num);
   }

   }

   class Demo03ThreadA extends Thread{

   private Demo03Service service;
   public Demo03ThreadA(Demo03Service service){
       this.service = service;
   }
   @Override
   public void run() {
       service.add("a");
   }

   }

   class Demo03ThreadB extends Thread{

   private Demo03Service service;
   public Demo03ThreadB(Demo03Service service){
       this.service = service;
   }
   @Override
   public void run() {
       service.add("b");
   }

   }

synchronized取得的锁都是对象锁，而不是把一段代码或方法作为锁，所以那个线程先执行带synchronized关键字修饰的方法，哪个方法就持有该方法所属对象的锁，其它线程只能呈等待状态，前提是多个线程访问的是同一个对象。如果多个线程访问多个对象，JVM会创建出多个对象锁。

1. synchronize方法锁的是整个对象

   package chap2;

   public class Demo04 {

   public static void main(String[] args) {
       Demo04Service service = new Demo04Service();
       Thread t1 = new Demo04ThreadA(service);
       Thread t2 = new Demo04ThreadB(service);
       t1.start();
       t2.start();
   }

   }

   class Demo04Service {

   synchronized public void foo1(){
       System.out.println("开始运行foo1方法，threadName：" + Thread.currentThread().getName());
       try {
           Thread.sleep(2000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("foo1方法运行结束");
   }
   synchronized public void foo2(){
       System.out.println("开始运行foo2方法，threadName：" + Thread.currentThread().getName());
       try {
           Thread.sleep(2000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("foo2方法运行结束");
   }

   }

   class Demo04ThreadA extends Thread{

   private Demo04Service service;
   public Demo04ThreadA(Demo04Service service){
       this.service = service;
   }
   @Override
   public void run() {
       service.foo1();
   }

   }

   class Demo04ThreadB extends Thread{

   private Demo04Service service;
   public Demo04ThreadB(Demo04Service service){
       this.service = service;
   }
   @Override
   public void run() {
       service.foo2();
   }

   }

A线程先持有Object对象的对象锁，B线程就不可以异步方式调用Object对象使用Synchronize修饰的方法，线程B只能等线程A的方法执行完成释放对象锁才能够执行，也就是同步执行。B线程可以以异步的方式调用Object对象没有使用synchronize修改的方法。

1. 脏读

   package chap2;

   public class Demo05 {

   public static void main(String[] args) throws InterruptedException {
       Demo05User user = new Demo05User();
       Thread t = new Demo05Thread(user);
       t.start();
       Thread.sleep(200);
       user.getValue();
   }

   }

   class Demo05User{

   private String username = "a";
   private String password = "aa";
   synchronized public void setUsernameAndPassword(String username, String password){
       this.username = username;
       try {
           Thread.sleep(2000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       this.password = password;
       System.out.println("setUsernameAndPassword方法，线程名称：" + Thread.currentThread().getName() +
               "，username=" +username + ", password=" + password);
   }
   synchronized public void getValue(){
       System.out.println("getValue方法，线程名称" + Thread.currentThread().getName() +
               ", username=" + username + ", password=" + password );
   }

   }

   class Demo05Thread extends Thread{

   private Demo05User user;
   public Demo05Thread(Demo05User user){
       this.user = user;
   }
   @Override
   public void run() {
       user.setUsernameAndPassword("B", "BB");
   }

   }

当A线程调用使用synchronize关键字修饰的方法时，A线程就获取到一个方法锁，准确来说是获取到对象锁，所以其它线程必须等A线程执行完毕后才可以调用其它使用synchrnoize修改的方法。这时A线程已经执行完一个完整任务，也就是说username和password两个成员变量已经被同时赋值，所以不存在脏读的。

1. 锁重入

关键字synchronized拥有锁重入的功能，就是说在使用synchronized时，当一个线程得到一个对象锁后，再次请求些对象锁时是可以再次得到该对象锁。

package chap2;
public class Demo06 {
    public static void main(String[] args) {
        Thread t = new Demo06Thread();
        t.start();
    }
}
class Demo06Service{
    synchronized public void foo1(){
        System.out.println("foo1方法");
        foo2();
    }
    synchronized public void foo2(){
        System.out.println("foo2方法");
        foo3();
    }
    synchronized public void foo3(){
        System.out.println("foo3");
    }
}
class Demo06Thread extends Thread{
    @Override
    public void run() {
        Demo06Service service = new Demo06Service();
        service.foo1();
    }
}

可重入锁也支持父子类继承的环境中。

package chap2;
public class Demo06 {
    public static void main(String[] args) {
        Thread t = new Demo06Thread();
        t.start();
    }
}
class Demo06Service{
    synchronized public void foo1(){
        System.out.println("foo1方法");
        foo2();
    }
    synchronized public void foo2(){
        System.out.println("foo2方法");
        foo3();
    }
    synchronized public void foo3(){
        System.out.println("foo3");
    }
}
class Demo06ServiceB extends Demo06Service{
    synchronized public void foo4(){
        System.out.println("foo4方法");
        super.foo1();
    }
}
class Demo06Thread extends Thread{
    @Override
    public void run() {
//        Demo06Service service = new Demo06Service();
//        service.foo1();
        Demo06ServiceB serviceB = new Demo06ServiceB();
        serviceB.foo4();
    }
}

1. 锁的自动释放

当一个线程执行的代码出现了异常，其所持有的锁会自动释放。

package chap2;
public class Demo07 {
    public static void main(String[] args) {
        Demo07Service service = new Demo07Service();
        Thread t1 = new Demo07Thread(service);
        t1.setName("A");
        t1.start();
        Thread t2 = new Demo07Thread(service);
        t2.start();
    }
}
class Demo07Service {
    synchronized public void foo(){
        if ("A".equals(Thread.currentThread().getName())){
            System.out.println("线程A开始于" + System.currentTimeMillis());
            while(true){
                if(("" + Math.random()).substring(0, 8).equals("0.123456")){
                    System.out.println("线程A结束于" + System.currentTimeMillis());
                    Integer.parseInt("A");
                }
            }
        }else{
            System.out.println("线程B开始于" + System.currentTimeMillis());
        }
    }
}
class Demo07Thread extends Thread{
    private Demo07Service service;
    public Demo07Thread(Demo07Service service){
        this.service = service;
    }
    @Override
    public void run() {
        service.foo();
    }
}