javase进阶 - 多线程

JavaSE进阶 - 多线程

1、基本概念

什么是进程？

进程是一个应用程序（1个进程是一个软件）。

什么是线程？

线程是一个进程中的执行场景/执行单元，一个进程可以启动多个线程。

对于Java程序来说，当在DOS命令窗口中输入：

java HelloWorld 回车之后

会先启动JVM，而JVM就是一个进程，JVM在启动一个主线程调用main方法，同时在启动一个垃圾回收器线程负责看护，回收垃圾。一个是垃圾回收器线程、一个是执行main方法的主线程。

进程和线程之间是什么关系？

阿里巴巴：进程
	马云：阿里巴巴的一个线程
	童文红：阿里巴巴的一个线程

进程可以看做是现实生活当中的公司，线程可以看做是公司当中的某个员工。

注意：

进程A和进程B的内存独立不共享（即两个进程之间的内存不共享）。

在Java语言中：线程A和线程B，堆内存和方法区内存共享，但是栈内存独立，一个线程一个栈。假设启动10个线程，就会有10个栈空间，每一个栈和栈之间互不干扰，各自执行各自的，这就是多线程并发。

如：火车站可以看做四一个进程。

在火车站中的每一个售票窗口可以看做是一个线程。我在窗口1购票，你可以在窗口2购票，我们两个都不需要互相等对方，所有多线程并发可以提供效率。

Java中之所以有多线程机制，目的就是为了提供程序的处理效率。

思考一个问题：

使用了多线程机制之后，main()方法结束，是不是有可能程序也不会结束，main()方法结束只是主线程结束了，主栈空了，其他的栈（进程）可能还在压栈弹栈。

分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发？

对于多核的CPU来说，真正的多线程并发是没有问题的。4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。

什么是真正的多线程并发？
	t1线程执行t1的。
	t2线程执行t2的。
	他们两个并不会互相干扰，这叫做真正的多线程并发。

单核的CPU表示只有一个大脑：不能够做到真正的多线程编发，但是可以做到给人一个“多线程并发”的感觉。对于单核的CPU来说，在某个时间点上实际上只能处理一件事情，但是由于CPU的处理数独极快，多个线程之间“频繁切换”执行，给人的感觉就是：多个事情同时在做！

电影院采用胶卷播放电影，一个胶卷一个胶卷播放发速度达到一定的程度之后，人类的眼睛产生了错觉，感觉是动画的。在这个期间计算机可以进行亿万次的循环，因为计算机的执行速度很快。

package com.zh0u.javase.thread;

/*
分析以下程序有几个线程，除垃圾回收器之外。有几个线程？
    答案：只有一个线程（因为程序只有一个“栈”）。注：一个“方法”不等于一个“栈”。
        main begin!
        m1 begin!
        m2 begin!
        m3 execute!
        m2 over!
        m1 over!
        main over!
    一个栈中，自上而下的顺序依次逐行执行！
 */
public class ThreadTest01 {
    public static void main(String[] args) {
        System.out.println("main begin!");
        m1();
        System.out.println("main over!");
    }

    private static void m1() {
        System.out.println("m1 begin!");
        m2();
        System.out.println("m1 over!");
    }

    private static void m2() {
        System.out.println("m2 begin!");
        m3();
        System.out.println("m2 over!");
    }

    private static void m3() {
        System.out.println("m3 execute!");
    }
}

2、多线程的实现

2.1、方法一：继承Thread

package com.zh0u.javase.thread;

/*
实现线程的第一种方式：
    编写一个类，直接继承java.lang.Thread并重写其中的run()方法。

    怎么创建线程对象？new就可以了。
    怎么启动线程？调用线程对象的start()方法。

注意：
    亘古不变的规定：方法题当中的代码永远都是自上而下的顺序依次逐行执行。

以下程序的输出结果有这样的特点：
    有先有后、有多有少。
    这是咋回事？这里先画一个问号？
 */
public class ThreadTest02 {
    public static void main(String[] args) {
        // 这里是main()方法，这里的代码属于主线程，在主栈中运行。
        // 新建一个分支线程对象
        MyThread t = new MyThread();
        // 启动线程
        // t.run(); // 不会启动线程，不会分配新得分支栈（这种方式就是单线程）。
        /*
        start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的占空间，这段代码任务完成之后，瞬间就结束了。
        这段代码的任务只是为了开启一个新的栈空间，只要新的占空间开出来，start()方法立即就结束了，线程就启动成功了。
        启动成功的线程会自动调用run()方法，并且run()方法在分支栈的栈底部（压栈）。
        run()方法在分支栈的底部，main()方法在主栈的底部，run()和main()是平级的。
         */
        t.start();
        // 这里的代码还是运行在主线程中
        for (int i = 0; i < 1000; i++) {
            System.out.println("main ---> " + i);
        }
    }
}

// 自定义线程类
class MyThread extends Thread{
    // 这里继承Thread的类必须重写run()方法
    public void run() {
        // 编写程序，这段程序运行在分支线程当中（分支栈）。
        for (int i = 0; i < 1000; i++) {
            System.out.println("myThread ---> "+i);
        }
    }
}

2.2、run与start

直接执行：

 t.run();

myThread ---> 0
...
myThread ---> 990
myThread ---> 991
myThread ---> 992
myThread ---> 993
myThread ---> 994
myThread ---> 995
myThread ---> 996
myThread ---> 997
myThread ---> 998
myThread ---> 999
main ---> 0
main ---> 1
main ---> 2
main ---> 3
main ---> 4
main ---> 5
main ---> 6
main ---> 7
main ---> 8
main ---> 9
main ---> 10
...
main ---> 999

t.start();

main ---> 0
myThread ---> 0
myThread ---> 1
myThread ---> 2
myThread ---> 3
myThread ---> 4
myThread ---> 5
myThread ---> 6
main ---> 1
main ---> 2
main ---> 3
main ---> 4
myThread ---> 7
main ---> 5
myThread ---> 8
main ---> 6
myThread ---> 9
myThread ---> 10
myThread ---> 11
myThread ---> 12
main ---> 7
myThread ---> 13
main ---> 8
myThread ---> 14
main ---> 9
myThread ---> 15
main ---> 10
main ---> 11
main ---> 12
myThread ---> 16
main ---> 13
myThread ---> 17
main ---> 14
myThread ---> 18
main ---> 15
main ---> 16
myThread ---> 19
main ---> 17
main ---> 18
main ---> 19
myThread ---> 20
main ---> 20
myThread ---> 21
main ---> 21
myThread ---> 22
main ---> 22
myThread ---> 23
...

2.3、方法二：实现Runnable

package com.zh0u.javase.thread;

/*
实现多线程的第二种方法：实现Runnable接口
 */
public class ThreadTest03 {
    public static void main(String[] args) {
        // 创建一个可运行对象
        // MyRunnable myRunnable = new MyRunnable();
        // 将可运行的对象封装成一个线程对象
        // Thread t = new Thread(myRunnable);
        // 直接写成一句代码
        Thread thread = new Thread(new MyRunnable());
        // 启动线程
        thread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程 ----> " + i);
        }
    }
}

// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("分支线程 ---> "+i);
        }
    }
}

第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其他的类，更灵活。

2.4、采用匿名内部类实现

package com.zh0u.javase.thread;

/*
采用匿名内部类的形式实现。
 */
public class ThreadTest04 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类的方式。
        // 这是通过一个没有名字的类，new出来的对象。
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("t线程--->" + i);
                }
            }
        });

        // 启动线程
        t.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main线程--->" + i);
        }
    }
}

3、线程的生命周期

新建状态、就绪状态、运行状态、阻塞状态、死亡状态。

​

4、获取当前线程对象

package com.zh0u.javase.thread;

/*
1、怎么获取当前线程对象。
    Thread t = Thread.currentThread();
    返回值t即使当前线程。

2、获取线程对象的名字。
    String name = 线程对象.getName();
3、修改线程对象的名字。
    线程对象.setName("线程名字");
4、当线程没有设置名字的时候，默认的名字有什么规律？
    Thread-0
    Thread-1
    Thread-2
    Thread-3
    ……
 */
public class ThreadTest05 {
    public static void main(String[] args) {
        // currentThread就是当前线程对象
        // 这个代码出现在main()方法当中，所以当前线程就是主线程
        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName());  // main

        // 创建线程对象
        MyThread2 thread2 = new MyThread2();
        /*
        // 设置线程的名字
        thread2.setName("robots1");
        // 获取线程的名字
        System.out.println(thread2.getName()); // robots1
         */
        // 以下使用线程的默认名称
        String thread2Name = thread2.getName();
        System.out.println(thread2Name); // Thread-0

        MyThread2 thread21 = new MyThread2();
        System.out.println(thread21.getName()); // Thread-1

        // 启动线程
        thread2.start();
        thread21.start();
    }
}

class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // currentThread就是当前线程对象。当前对象是谁呢？
            // 当Thread-0线程执行run()方法时，那么这个当前线程就是Thread-0
            // 当Thread-1线程执行run()方法时，那么这个当前线程就是Thread-1
            Thread currentThread = Thread.currentThread();
            System.out.println(currentThread.getName() + " ---> " + i);
        }
    }
}

5、sleep()

package com.zh0u.javase.thread;

/*
关于线程的sleep()方法：
    public static void sleep(long millis) throws InterruptedException
    1、静态方法：Thread.sleep(1000);
    2、参数是毫秒
    3、作用：让“当前线程”进入休眠，进入“阻塞状态”，放弃占有CPU的时间片，让给其他线程使用。
        这行代码出现在A线程中，A线程就会进入休眠。
        这行代码出现在B线程中，B线程就会进入休眠。
    4、Thread.sleep()方法，可以做到这种效果：
        间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。
 */
public class ThreadTest06 {
    public static void main(String[] args) {
        // 让当前线程进入休眠，睡眠5秒
        // 当前线程是主线程！
        /*
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 5秒之后执行这里的代码
        System.out.println("hello world");
        */

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "->" + i);

            // 睡眠 1 秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5.1、唤醒sleep中的线程

package com.zh0u.javase.thread;

import java.awt.print.PrinterException;

/*
sleep()方法睡眠时间太长了，如果希望半道醒来，应该咋样做？
    注意：这个不是中断线程的执行，是终止线程的睡眠。
 */
public class ThreadTest08 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyThread4());
        t.setName("t");
        t.start();

        // 希望5秒之后，t线程醒来（5秒钟之后主线程手里的活儿干完了）。
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 终止t线程的睡眠（这种中断睡眠的方式依靠了Java的异常处理机制）。
        t.interrupt(); //直接唤醒
    }
}

class MyThread4 implements Runnable{

    /*
    重点：run()当中的异常不能throws，只能try catch。
    因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。
     */
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "-> begin!");
        try {
            // 睡眠一年
            Thread.sleep(1000*60*60*24*365);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 一年之后才会执行这里
        System.out.println(Thread.currentThread().getName() + "-> over!");
    }
}

5.2、sleep()面试题：

package com.zh0u.javase.thread;

/*
关于Thread.sleep()方法的一个面试题。
 */
public class ThreadTest07 {
    public static void main(String[] args) {
        // 创建线程对象
        Thread thread3 = new MyThread3();
        thread3.setName("t");
        thread3.start();

        // 调用sleep()方法
        try {
            // 问题：这行代码会让线程thread3进入休眠状态吗？
            /*
            答案：
                在执行的时候还是会转换成：Thread.sleep(1000*5);（因为sleep是静态方法）
                这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。
                这行代码出现在main方法当中，main线程睡眠。
                所以：下面的hello world会在5秒之后再输出。
             */
            thread3.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello world");
    }
}

class MyThread3 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

6、终止线程的两种方法

6.1、stop()方法

package com.zh0u.javase.thread;

/*
在Java中怎么强行终止一个线程的执行：
    这种方式存在很大缺点：容易丢失数据。因为这种方式是直接将线程杀死了，线程中
    没有保存的数据将会丢失。不建议使用。
 */
public class ThreadTest09 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyThread5());
        t.setName("t");
        t.start();

        // 模拟5秒
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 5秒之后强行终止t线程
        t.stop(); // 已过时（不建议使用）
    }
}

class MyThread5 implements Runnable{

    @Override
    public void run() {

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

6.2、Boolean判断（推荐）

package com.zh0u.javase.thread;

/*
合理终止一个线程执行的方式，这种方法很常用。
 */
public class ThreadTest10 {
    public static void main(String[] args) {
        MyRunnable1 r = new MyRunnable1();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();

        // 模拟5秒
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 终止线程
        // 想要什么时候终止t的执行，那么吧标志改成false就可以了。
        r.flag = false;
    }
}

class MyRunnable1 implements Runnable{

    // 打一个Boolean标记
    boolean flag = true;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (flag) {
                System.out.println(Thread.currentThread().getName() + "->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                // return就结束了，在结束之前还有什么没有保存的，在这里可以保存。
                // save...

                // 终止当前线程
                return;
            }
        }
    }
}

7、线程调度（了解）

7.1、常见的线程调度模型

**抢占式调度模型：**那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。Java采用的就是抢占式调度模型。

**均分式调度模型：**平均分配CPU时间片，每个线程占有的CPU时间片的时间长度一样。有些编程语言线程调度模型采用的就是这种方式。

Java中提供的方法和线程调度有什么关系？

实例方法：
	void setPriority(int newPriority); 设置线程的优先级
	int getPriority(); 返回线程的优先级
	最低优先级 1
	默认优先级 5
	最高优先级 10
	优先级比较高的获取CPU时间片可能会多一些（但也不完全是，大概率是多的）。
	
静态方法：
	static void yield(); 暂停当前正在执行的线程对象，并执行其他线程。
	yield()方法不是阻塞方法，让当前线程让位，让给其他线程使用。
	yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
	注意：在回到就绪状态后，有可能还会再次抢到。

实例方法：
	void join(); 合并线程。
    
    class MyThread1 extends Thread {
    	public void doDome(){
    		MyThread2 t = new MyTread2();
    		// 当前线程进入阻塞，t线程执行，知道t线程结束，当前线程才可以继续执行。
    		t.join(); 
    	}
    }
	

优先级：

package com.zh0u.javase.thread;

/*
了解：关于线程的优先级。
 */
public class ThreadTest11 {
    public static void main(String[] args) {
        // 设置主线程的优先级为1
        Thread.currentThread().setPriority(1);

        /*
        System.out.println("最高优先级" + Thread.MAX_PRIORITY); // 10
        System.out.println("最低优先级" + Thread.MIN_PRIORITY); // 1
        System.out.println("默认优先级" + Thread.NORM_PRIORITY); // 5
        */

        // 获取当前线程对象，获取当前线程优先级
        // Thread currentThread = Thread.currentThread();
        // System.out.println(currentThread.getName() + "线程的默认优先级是" + currentThread.getPriority()); // 5

        // 创建MyRunnable2线程子类
        Thread t = new Thread(new MyRunnable2());
        // 设置t线程的优先级
        // 优先级较高的，只是抢到的CPU时间片相对较多一些。即更偏向优先级较高的那个。
        t.setPriority(10); // 设置为最高优先级
        t.setName("t");
        t.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
}

class MyRunnable2 implements Runnable{

    @Override
    public void run() {
        // 输出：t线程的优先级5
        // System.out.println(Thread.currentThread().getName() + "线程的优先级" + Thread.currentThread().getPriority());

        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
}

yield()方法:

package com.zh0u.javase.thread;

/*
yield()方法，当前线程让位。
 */
public class ThreadTest12 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable4());
        t.setName("thread");
        t.start();

        for (int i = 1; i <= 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
}

class MyRunnable4 implements Runnable{
    int count = 0;

    @Override
    public void run() {
        for (int i = 1; i <= 10000; i++) {
            // 每100个让位一次
            if (i % 100 == 0){
                Thread.yield(); // 当前线程暂停一下，让给主线程。
            }
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
}

join()方法：

package com.zh0u.javase.thread;

/*
join()方法，阻塞当前线程。即线程合并。

 */
public class ThreadTest13 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable5());
        thread.setName("t");
        thread.start();

        System.out.println(Thread.currentThread().getName()+" begin!");
        // 使用join()方法将thread线程加入到当前main线程，当前线程（main）会被阻塞thread线程执行完毕之后才会执行main线程。
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" over!");
        /*
        输出：
            main begin!
            t->0
            t->1
            t->2
            t->3
            t->4
            t->5
            ……
            t->99
            main over!
         */
    }
}

class MyRunnable5 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
}

8、多线程安全(重点）* * * * *

为什么这个是重点？

以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义、线程对象的创建，线程的启动等都已经实现了。这些代码不需要我们编写。

最重要的是要知道，自己所编写的程序响应放到一个多线程的环境下运行，你更新于关注的是这些数据在多线程并发的环境下是否是安全的。

什么时候数据在多线程并发的环境下会存在安全问题？

如在银行取款问题：

线程安全问题的三个条件：

1. 多线程并发；
2. 有共享数据；
3. 共享数据有修改的行为；

满足以上3个条件之后，就会存在线程安全问题。

怎么解决线程安全问题？

当多线程并发的华景下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？

可以让线程“排队执行”（不能并发）。
用派对之星解决线程安全问题，这种机制被称为：线程同步机制。

专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。

怎么解决线程安全问题？
	使用“线程同步机制”。
	
线程通过就是线程排队，线程排队了就会牺牲一部分效率，但是没有办法，数据安全第一位，只有数据安全了，才可以谈效率。如果数据不安全，就没有效率这一说。

线程通过与线程异步：

异步编程模型： -> 异步就是并发

线程t1和线程t2，各自执行各自的，t1不用管t2，t2不用管t1，谁也不需要等待谁，这种编程模型叫做：异步编程模型，其实就是“多线程并发（效率较高）”。

同步编程模型： - 同步就是排队

线程t1和线程t2，在t1线程执行之前，必须等待t2线程执行完毕，或者说在执行t2线程之前，必须等待t1线程完毕。两个线程之间发生了等待关系，这就是同步编程模型。

异步导致安全问题：

Account.java

package com.zh0u.javase.threadSafe;

/*
银行账户类
 */
public class Account {
    // 银行账号
    private String actno;
    // 账号余额
    private double balance;

    public  Account(){

    }

    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

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

    // 取款
    public void withdraw(double money){
        // 全款之前的余额
        // t1和t2并发这两个方法（t1和t2是两个站。两个栈操作堆中同一个对象。
        double before = this.balance;
        // 取款之后的余额
        double after = before - money;
        // 模拟网络延迟 1 秒钟，此时一定出现问题。
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 更新余额
        // 思考：t1执行到这里了，但还没有来得及执行这行代码，t2线程进来执行withdraw()方法了，此时一定出现问题。
        this.setBalance(after);
    }
}

AccountThread.java

package com.zh0u.javase.threadSafe;

public class AccountThread extends Thread{
    // 两个线程必须共享同一个账户对象
    private Account act;

    // 通过构造方法传递过来账户对象
    public AccountThread(Account act){
        this.act = act;
    }

    public void run(){
        // run()方法的执行表示取款操作
        // 假设取款5000
        double money = 5000;
        // 取款
        act.withdraw(money);

        String message = Thread.currentThread().getName() + "对账户" + act.getActno() +
                "取款"+money+"成功，余额为：" + act.getBalance();

        System.out.println(message);
    }
}

Test.java

package com.zh0u.javase.threadSafe;

public class Test {
    public static void main(String[] args) {
        // 创建账户对象（只创建一个）
        Account act = new Account("act--001", 10000);
        // 创建两个线程
        AccountThread t1 = new AccountThread(act);
        AccountThread t2 = new AccountThread(act);
        // 设置线程名字
        t1.setName("t1");
        t2.setName("t2");

        // 启动线程取款
        t1.start();
        t2.start();
    }
}

8.1、synchronized关键字

使用synchronized关键字解决上面的问题：

	// 取款
    public void withdraw(double money){
        // 以下这几行代码必须是线程排队的，不能并发。
        // 一个线程把这里的代码全部执行完毕之后。另一个线程才能执行。
        /*
        线程同步机制的语法是：
            synchronized(){
                // 线程同步代码块。
            }
            synchronized后面小括号中传的这个“数据”是相当关键的。
            这个数据必须是多线程共享的数据，才都能达到多线程排队。

            ()中写什么？
                那要看想让那些线程同步。
                假设t1、t2、t3、t4、t5有5个线程。
                你只希望t1、t2、t3排队，t4、t5不需要排队。怎么办？
                你一定要在()中写一个t1、t2、t3共享的对象。而这个对象对于t4、t5来说不是共享的。

            这里的共享对象是：账户对象。
            账户对象是共享的，那么this就是账户对象！！！

            这里的()号中不一定是this，这里只要是多线程共享的那个对象就可以。

            在Java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记（只是把它叫做“锁”）。
            1个对象一把锁，100个对象100把锁。

            以下代码的执行原理：
                1、假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
                2、假设t1先执行了，遇到synchronized关键字，这个时候自动找“后面共享对象”的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的。直到同步代码块结束才会释放这把锁。
                3、假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁
                被t1占用，t2只能在同步代码块外面等待t1的结束，直到t1把同步代码块中的所有代码都执行完毕了，t1才会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后，进入同步代码块执行程序。

                这样就达到了线程排队执行。
                这里需要注意的是：这个共享对象一定要选好，这个共享对象一定是需要排队执行的这些线程对象所共享的。
         */
        // Object object = new Object();
        // synchronized (antno){ // 这行代码也可以，因为antno为实例变量，是共享对象。
        // synchronized (object){ // 这行代码就不行，object是局部变量，不是共享对象。
        // synchronized ("abc") { // "abc"在字符串常量当中，这个也行，但是写这个的话，所有的线程都会同步（t1,t2,t3,t4,t5...)。
         synchronized (this){
            double before = this.balance;
            double after = before - money;
            // 模拟网络延迟 1 秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }

解决的第二种方式：

// 取款
/*
在实例方法上可以使用synchronized。
    synchronized出现在实例方法上，一定锁的是this，不能是其他对象，所以这种方式不太灵活。
    另外还有一点：synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序执行效率降低。
    所有这种方式不常用。

    synchronized使用在还实例方法上有什么优点？
        代码写的少。

如果共享对象是this，并且需要同步的代码块是整个方法体，建议使用这种方式。
 */
public synchronized void withdraw(double money){}

输出：

t1对账户act--001取款5000.0成功，余额为：5000.0
t2对账户act--001取款5000.0成功，余额为：0.0

8.2、synchronized的三种写法

synchronized的三种写法：
第一种：同步代码块，灵活
	synchronized (线程共享对象){
		同步代码块;
	}

第二种：在实例方法上使用synchronized
	表示共享对象一定是this，并且同步代码块是整个方法体。
	
第三种：在静态方法上使用synchronized，即可以使用类锁来保护“静态变量”的安全。
	表示找“类锁”，类锁永远只有1把，就算创建了100个对象，那类锁也只有一把。

8.3、synchronized面试题

第一个：

package com.zh0u.javase.exam1;

/*
面试题：doOther()执行的时候不需要等待doSome()方法的结束吗？
答案：不需要，因为doOther()方法没有synchronized关键字修饰，执行的时候不需要共享对象执行锁。
 */
public class Exam01 {
    public static void main(String[] args) {
        MyClass mc = new MyClass();
        MyThread t1 = new MyThread(mc);
        MyThread t2 = new MyThread(mc);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        // 这个睡眠的作用是为了保证t1先执行。
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

class MyThread extends Thread{
    private final MyClass myClass;

    public MyThread(MyClass myClass){
        this.myClass = myClass;
    }

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("t1"))
            myClass.doSome();
        if (Thread.currentThread().getName().equals("t2"))
            myClass.doOther();
    }
}

class MyClass{
    // 会获取共享对象锁
    public synchronized void doSome(){
        System.out.println("doSome begin!");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over!");
    }
    public void doOther(){
        System.out.println("doOther begin!");
        System.out.println("doOther over!");
    }
}

第二个：

package com.zh0u.javase.exam2;

/*
面试题：doOther()执行的时候不需要等待doSome()方法的结束吗？
答案：需要，因为synchronized修饰静态方法doSome()与doOther()方法，这里会执行一个类锁。
 */
class Exam02 {
    public static void main(String[] args) {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();
        MyThread t1 = new MyThread(mc1);
        MyThread t2 = new MyThread(mc2);

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        // 这个睡眠的作用是为了保证t1先执行。
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

class MyThread extends Thread{
    private final MyClass myClass;

    public MyThread(MyClass myClass){
        this.myClass = myClass;
    }

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("t1"))
            MyClass.doSome();
        if (Thread.currentThread().getName().equals("t2"))
            MyClass.doOther();
    }
}

class MyClass{
    // synchronized出现在静态方法上，表示类锁，一个类锁可以对很多个对象。
    public synchronized static void doSome(){
        System.out.println("doSome begin!");
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("doSome over!");
    }
    public synchronized static void doOther(){
        System.out.println("doOther begin!");
        System.out.println("doOther over!");
    }
}

8.4、Java中的三大变量

实例变量 ：在堆中。

静态变量 ：在方法区。

局部变量 ：在栈中。

以上三大变量中：
局部变量永远不会存在线程安全问题。因为局部变量不共享（一个线程一个栈），局部变量在占中，所有局部变量永远都不会共享。

实例变量在堆中，堆只有一个。静态变量在方法区中，方法区只有一个。堆和方法区都市多线程共享的，所以有可能存在线程安全问题。

如：在进行字符串拼接的时候，如果使用局部变量，建议使用StringBuilder，因为局部变量不存在线程安全问题。选择StringBuffer效率相对降低。

8.5、死锁

package com.zh0u.javase.deadLock;

/*
死锁代码要会写，一般面试官要求会写，只有会写，才会在以后的开发中重视这个事。
因为死锁很难调试。
synchronized在开发中最好不要嵌套使用，否则一不小心就好出现死锁这种情况。
 */
public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        // t1和t2两个线程共享o1，o2
        MyThread1 t1 = new MyThread1(o1, o2);
        MyThread2 t2 = new MyThread2(o1, o2);

        t1.start();
        t2.start();
    }
}

class MyThread1 extends Thread{
    Object o1;
    Object o2;

    public MyThread1(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o1){
            // 让程序睡一秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){
                System.out.println("doSome!");
            }
        }
    }
}

class MyThread2 extends Thread{
    Object o1;
    Object o2;

    public MyThread2(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2){
            // 让程序睡一秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){
                System.out.println("doSome!");
            }
        }
    }
}

聊一聊以后在开发中怎么解决线程安全问题？

是一上来就选择线程同步吗？

不是，synchronized会让程序的执行效率降低，用户体验不好，系统的用户吞吐量降低。用户体验差。在不得已的情况下在选择线程同步机制。

第一种方案：尽量使用局部变量代替“实例变量”和“静态变量”。

第二种方案：如果必须使用实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应一个对象，100个线程对应100个对象，对象不共享，就没有数据的安全问题了）。

第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。

9、守护线程

Java语言中线程分为两大类：一类是用户线程，另一类是守护线程（后台线程）。其中守护线程具有代表性的就是“垃圾回收器”。

守护线程的特点：一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。

注意：主线程main方法是一个用户线程。

package com.zh0u.javase.thread;

/**
 * 守护线程
 */
public class ThreadTest14 {
    public static void main(String[] args) {
        Thread t = new BakDataThread();
        t.setName("备份数据的线程");

        // 启动线程之前，将线程设置为守护线程
        t.setDaemon(true);
        t.start();

        // 主线程：主线程是用户线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class BakDataThread extends Thread{
    @Override
    public void run() {
        int i = 0;
        // 即使是死循环，但由于该线程是守护线程，当用户线程结束时，守护线程自动终止。
        while (true){
            System.out.println(Thread.currentThread().getName() + "->" + (++i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

10、定时器

定时器的作用：间隔特定的时间，执行特定的程序。

如：每周要进行银行账户的总账操作，每天要进行数据的备份操作。

在实际的开发中，每个多久执行一段特定的程序，这种需求是很常见的，那么在Java其实可以有多种实现的方式：

可以使用sleep方法睡眠，设置睡眠时间，每到这个时间点醒来，执行任务。这种方式是最原始的定时器（比较low）。

在Java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用，不过，这种方式在目前的开发中也很少用，因为现在很多高级框架都是支持定时任务的。

在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架（底层还是java.util.Timer），这个框架只要进行简单的配置就可以完成定时器的任务。

未完……