多线程、并发/并行、自定义线程类、线程安全、守护线程、定时器、线程状态、线程池

1、效率高。（多线程通过提高CPU利用率来提高效率。数据库访问、磁盘IO等操作的速度比CPU执行代码速度慢很多，单线程环境下，这些操作会阻塞程序执行，导致CPU空转，因此对于会产生这些阻塞的程序来说，使用多线程如果一个线程阻塞，CPU可以先去执行其他线程，避免在等待期间CPU的空转，提高CPU利用率。）

2、多个线程之间互不影响。（如果代码抛出了异常，只有一个线程停止了工作，其他线程可以继续执行）

线程调度：

分时调度：

所有线程轮流得到CPU的使用权，平均分配每个线程占用CPU的时间。

抢占式调度：

让优先级高的线程先使用CPU，如果多个线程之间的优先级相同，那么随机选择一个线程执行，Java使用的是抢占式调度。

另外，在java语言中：多个线程共享同一个堆内存和方法区内存。但是栈内存独立，一个线程一个栈，互不干扰。

再者，不管main方法调用了几个方法，只要它还是一个栈，那就只有一个线程。

思考一个问题：使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束？

不会。main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在
压栈弹栈。

并发与并行：

并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。就好像两个人各拿一把铁锨同时在挖坑，一小时后，每人一个大坑。所以无论从微观还是从宏观来看，二者都是一起执行的。

并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。这就好像两个人用同一把铁锨，轮流挖坑，一小时后，两个人各挖一个小一点的坑，要想挖两个大一点得坑，一定会用两个小时。

并行在多处理器系统中存在，而并发可以在单处理器和多处理器系统中都存在（当进程的数量大于CPU时，计算机就无法同时执行多个线程，也就是并行，这时候又会转入并发状态，一个CPU高速轮转执行多个线程）。

并发是并行的假象（每个小时间片执行一个操作，多个操作快速切换执行）。

线程的生命周期：

实现线程的两种基本方式（还有第三种）：

创建Thread线程类。
创建Runnable线程类。

创建Thread线程类：

Java创建并启动Thread多线程的步骤如下：

创建一个Thread类的继承类。
在继承类中重写Thread类的run方法，设置线程任务。（当开启这个线程后，JVM自动调用该方法）
创建Thread子类的实例，即创建了线程对象。
调用线程对象的start()方法来启动该线程。

注意：多次启动同一个线程是非法的，特别是在该线程关闭了之后。

Java的线程调度是抢占式调度。（同一优先级下，多个线程同时抢占CPU的控制权，代码的执行顺序是不确定的）

class MyThread extends Thread{
    private String name;
    public MyThread(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for(int i = 0 ; i < 50 ; i++) {
            System.out.println(this.name + "正在工作中……" + i);
        }
    }
}

public class testThread {
    public static void main(String[] args) {
        // 实例化线程对象
        MyThread mt1 = new MyThread("线程一");
        MyThread mt2 = new MyThread("线程二");
        MyThread mt3 = new MyThread("线程三");
        // 启动实例线程对象
        mt1.start();
        mt2.start();
        mt3.start();
    }
}

输出结果：

当调用start()方法时，Java会开辟一个新的栈空间，并在新的栈空间中调用线程类的run()方法。

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

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

注意：
    亘古不变的道理：
        方法体当中的代码永远都是自上而下的顺序依次逐行执行的。
        t.run();执行完main方法中的循环才会执行，但因为它开启了一个分支栈，所有MyThread和main两个线程同时执行同时循环输出
        为抢占式调度。

 */
public class ThreadTest02 {
    public static void main(String[] args) {
        // 这里是main方法，这里的代码属于主线程，在主栈中运行。
        // 新建一个分支线程对象
        MyThread t = new MyThread();
        // 启动线程

        // t.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
        // start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。

        // t.start();这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
        // 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
        // run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
        t.start();
        // 这里的代码还是运行在主线程中。
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        // 编写程序，这段程序运行在分支线程中（分支栈）。
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

创建Runnable线程类：

Java创建并启动Thread多线程的步骤如下：

创建一个Runnable接口的实现类。
在实现类中重写Runnable接口的run方法，设置线程任务。
创建一个Runnable接口的实现类对象（即创建Runnable实现类对象）。
创建Thread类对象，在构造方法中传递Runnable接口的实现类对象。
调用Thread类中的start方法，开启新的线程执行run方法。

注意：Runnable接口并没有start()方法，要通过调用Thread类的构造方法才能运行新线程。

Thread(Runnable target); 直接传递Runnable实现类对象。

Thread(Runnable target, String name); 传递Runnable实现类对象，并给该线程定义一个名称。

/*
实现线程的第二种方式，编写一个类实现java.lang.Runnable接口。
 */
public class ThreadTest03 {
    public static void main(String[] args) {
        // 创建一个可运行的对象
        //MyRunnable r = new MyRunnable();
        // 将可运行的对象封装成一个线程对象
        //Thread t = new Thread(r);
        Thread t = new Thread(new MyRunnable()); // 合并代码
        // 启动线程
        t.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);
        }
    }
}

相对于继承Thread类，实现Runnable接口创建多线程程序的好处：

1、避免了单继承的局限性：

一个类只能继承一个类，类继承了Thread类就不能继承其他的类。而实现了Runnable接口，还可以继承其他的类，实现其他的接口。

2、增强了程序的扩展性，降低了程序的耦合性(解耦)：

实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)。

public class Demo {
    public void a(Runnable runnable){
        new MyThread().start();     // 这里就固定死了，只能创建MyThread类的线程。

        Thread thread = new Thread(Runnable r);   // 解耦，根据传过来的不同的Runnable实现类，创建不同类的线程
    }
}

3、如果一个类继承了Thread类，则不适合资源共享。但如果是实现类Runnable接口，则很容易资源共享。

4、线程池只能放实现类Runnable或Callable接口的类线程，不能直接放继承了Thread的类线程。

用内部类和lambda表达式创建新线程：

Runnable接口是一个函数式接口，可以使用lambda表达式。

// 匿名内部类的方式
public class Demo {
    public static void main(String[] args){
        new Thread(){
            @Override
            public void run() {
                System.out.println("线程1");
            }
        }.start();

        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("线程2");
            }
        }).start();


// lambda表达式的方式
        /*
        
        lambda表达式创建Runnable实例对象：

        Runnable runnable = ()->{
           System.out.println();
        };

        Thread类中的一个构造方法：

        public Thread(Runnable target) {
            init(null, target, "Thread-" + nextThreadNum(), 0);
        }

        */

        new Thread(()->{
            System.out.println();
        });
    }
}

Thread类常用的方法：

构造方法：

Thread(); 创建一个线程类对象。

Thread(String name); 创建一个线程类对象，名称为name。（可以在自定义的线程类中定义一个含参的构造方法，其中调用父类的构造方法，这样我们就可以在new线程类的对象的时候就定义该线程的名称）

Thread(Runnable target); 稍后介绍。

Thread(Runnable target, String name); 稍后介绍。

静态方法：

static Thread currentThread();        返回调用该方法的线程的引用，返回类型为Thread。

static sleep(long millis);        以指定毫秒数暂停该线程的执行。sleep会抛出异常。

实例方法：

void start();        启动已创建的线程对象。

void run();        由线程调度器调用，当从run()返回时，该线程运行结束。

final void setName(String name);        设置线程的名字。

final String getName();        返回线程的名字。（默认第一个为Thread-0，第二个为Thread-1.......）。

interrupt();        中断线程对象所处的状态。如果线程处于阻塞状态，调用该方法会使阻塞状态结束而进入就绪状态。此方法会抛出InterruptedException异常。

fianl boolean isAlive();        判断线程是否被启动，若被启动则返回true。

stop();   强制终止线程（已过时，不建议使用）（可能会丢失数据）

currentThread()方法常常搭配getName()方法来获得当前执行的线程名称。

（getName()是静态方法，可直接在继承Thread类的线程类中使用。而main方法没有继承Thread类，所有如果要得到main方法的线程名称（main），需要currentThread().getName()组合使用）

java中提供的和线程调度有关的方法：

实例方法：
void setPriority(int newPriority) 设置线程的优先级

int getPriority() 获取线程优先级

最低优先级1（常量MIN_PRIORITY）

默认优先级是5（常量NORM_PRIORITY）

最高优先级10（常量MAX_PRIORITY）

优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）

静态方法：
static void yield() 让位方法

使当前正在运行的线程暂时中断，变为就绪状态

暂停当前正在执行的线程对象，并执行其他线程

yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。

yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。

注意：在回到就绪之后，有可能还会再次抢到。

实例方法：
void join()
使当前线程暂停运行，等调用join方法的线程运行结束，当前线程才继续运行。也称为合并线程。

class MyThread1 extends Thread {
    public void doSome(){
        MyThread2 t = new MyThread2();
        t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
    }
}

class MyThread2 extends Thread{

}

合理的终止一个线程的执行：

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

        // 模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止线程
        // 你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
        r.run = false;
    }
}

class MyRunable4 implements Runnable {

    // 打一个布尔标记
    boolean run = true;

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

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

关于Sleep()方法的面试题：

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

        // 调用sleep方法
        try {
            // 问题：这行代码会让线程t进入休眠状态吗？
            t.sleep(1000 * 5); // 在执行的时候还是会转换成：Thread.sleep(1000 * 5);
                                     // 这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。
                                     // 这样代码出现在main方法中，main线程睡眠。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 5秒之后这里才会执行。
        System.out.println("hello World!");
    }
}

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

关于多线程并发环境下，数据的安全问题。

以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。我们只需要知道，我们编写的程序放到一个多线程的环境下运行，所涉及到的数据在多线程并发的环境下是否是安全的。

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

三个条件：

条件1：多线程并发。

条件2：有共享数据。

条件3：共享数据有修改的行为。

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

怎么解决线程安全问题呢？

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

线程排队执行。（不能并发）。用排队执行解决线程安全问题。

这种机制被称为：线程同步机制。专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。线程排队了会牺牲一部分效率，但没办法，数据安全是第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

线程同步涉及到这两个专业术语：

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

同步编程模型：

线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。

线程不安全的情况：

当多个线程共享一个数据时，如果两个线程同时拿到了这个数据的修改权，当一个线程把其中一个数据修改了，那么另一个线程将只能使用这个被修改过后的数据，这就导致了不安全。

下列示例取款代码就是一个线程不安全的代码：

/*
    测试类、main类
 */
public class Test {
    public static void main(String[] args) {
        // 创建账户对象（只创建1个）
        Account act = new Account("act-001", 10000);
        // 创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);
        // 设置name
        t1.setName("t1");
        t2.setName("t2");
        // 启动线程取款
        t1.start();
        t2.start();
    }
}

/*
    线程类
 */
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);

        System.out.println(Thread.currentThread().getName() + "对"+act.getActno()+"取款"+money+"成功，余额" + act.getBalance());
    }
}

/*
银行账户类
    不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题。
 */
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.getBalance(); // 10000
        // 取款之后的余额
        double after = before - money;

        // 在这里模拟一下网络延迟，100%会出现问题
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 更新余额
        // 思考：t1执行到这里了，但还没有来得及执行setBalance这行代码，t2线程进来withdraw方法了。
        // 查询到余额还是10000，此时一定出问题。
        this.setBalance(after);
    }
}

如何使得线程安全：

同步代码块：

语法格式：

synchronized (锁对象) {
    可能会出现线程安全问题的代码(访问了共享数据的代码)
    // 线程同步代码块
}

锁对象作用：把同步代码块锁住，只让一个线程在同步代码块中执行。

synchronized后面小括号中传的这个“数据”是相当关键的。这个数据必须是多线程共享的数据，才能达到多线程排队。

()中写什么？那要看你想让哪些线程同步。

假设t1、t2、t3、t4、t5，有5个线程，你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？

你一定要在()中写一个t1 t2 t3共享的对象。而这个对象对于t4 t5来说不是共享的。

注意:

1、同步代码块代码块中的锁对象，可以使用任意的对象。（一般为Object对象）

2.、必须保证多个线程使用的锁对象是同一个。

3、锁对象一般要定义在run()方法的外部，因为一旦定义在run()方法的内部，那么每个线程都有自己独有的锁对象，那么就起不到线程安全的作用了。

4、同步代码块内部所要执行的代码越少，效率越高。

代码示例（改进上述有问题的代码）：

/*
银行账户类
    不使用线程同步机制，多线程对同一个账户进行取款，出现线程安全问题。
 */
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){
        synchronized(this){    // 因为对象是共享的，多个线程共享一个账户对象，可以把this作为锁对象
        // 不一定是this，这里只要是多线程共享的那个对象就行。
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {    
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }
}

另外，Java有三大变量：

实例变量：在堆中。

静态变量：在方法区。

局部变量：在栈中。

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

关于锁对象的研究：

/*
银行账户
    使用线程同步机制，解决线程安全问题。
 */
public class Account {
    // 账号
    private String actno;
    // 余额
    private double balance; //实例变量。

    //对象
    Object obj = new Object(); // 实例变量。（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。）

    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){
        //Object obj2 = new Object();
        synchronized (this){
        //synchronized (obj) {  // 可以
        //synchronized ("abc") { // "abc"在字符串常量池当中，只要一个，可以。
            // 但注意，如果是字符串的形式，那么所有账户不论是不是同一个都不能并发了
            // 因为都指向同一个字符串常量对象
            // 但用this就不会出现这样的问题
        //synchronized (null) { // 报错：空指针。
        //synchronized (obj2) { // 这样编写就不安全了。因为obj2是局部变量，不是共享对象。
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    }
}

同步代码块实现原理：

锁对象又称为同步锁、对象锁、对象监视器。

3个线程一起抢夺cpu的执行权,谁抢到了谁执行run方法，遇到synchronized代码块后，线程会检查synchronized代码块是否有锁对象，如果有，就会获取到锁对象，进入到同步中执行。

如果其他线程执行run方法时发现synchronized代码块的锁对象被取走了，就会进入到阻塞状态，一直等待执行中的线程归还锁对象。

线程执行完同步中的代码，会把锁对象归还给同步代码块，下一个线程就可以获得锁对象进入到同步中执行代码。

同步中的线程没有执行完毕不会释放锁，同步外的线程没有锁进不去同步。

缺陷：程序频繁的判断锁，获取锁，释放锁，程序的效率会降低。

同步方法：

语法格式：

修饰符列表 synchronized 返回值类型 方法名(参数列表){

    可能会出现线程安全问题的代码(访问了共享数据的代码)

}

注意，synchronized修饰实例方法时，锁对象就是this，不灵活。

特别的，当同步方法是静态的时候，静态方法的锁对象是本类的class属性（是class文件本身）。又称为类锁。

类锁永远只有1把。

就算创建了100个该类的对象，那类锁也只有一把。

对象锁：1个对象1把锁，100个对象100把锁。

类锁：100个对象，也可能只是1把类锁。

（注意，当同步方法是静态的时候，不能访问类中的实例字段，因为实例字段在new对象的时候才会产生，而静态方法在类加载的时候就产生了，就会引用一个不存在的字段，Java会报错）

基于线程安全怎么选择该使用什么工具类：

如果使用局部变量的话：

建议使用：StringBuilder。因为局部变量不存在线程安全问题。如果选择StringBuilder，StringBuffer效率比较低。

另外：

ArrayList是非线程安全的。Vector是线程安全的。

HashMap、HashSet是非线程安全的。Hashtable是线程安全的。

synchronized面试题一：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    //不需要，因为doOther()方法没有synchronized
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();

        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

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

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：让main方法进入休眠，以保证t1线程先执行。
        t2.start();
    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc){
        this.mc = mc;
    }
    public void run(){
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.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");
    }
}

synchronized面试题二：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    //需要,因为锁住的是同一个对象
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc = new MyClass();

        Thread t1 = new MyThread(mc);
        Thread t2 = new MyThread(mc);

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

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc){
        this.mc = mc;
    }
    public void run(){
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.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 synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

synchronized面试题三：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    //不需要，因为锁住的是两个不相同的对象
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

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

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc){
        this.mc = mc;
    }
    public void run(){
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.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 synchronized void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");
    }
}

synchronized面试题四：

// 面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
    //需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把。
public class Exam01 {
    public static void main(String[] args) throws InterruptedException {
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass();

        Thread t1 = new MyThread(mc1);
        Thread t2 = new MyThread(mc2);

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

        t1.start();
        Thread.sleep(1000); //这个睡眠的作用是：为了保证t1线程先执行。
        t2.start();
    }
}

class MyThread extends Thread {
    private MyClass mc;
    public MyThread(MyClass mc){
        this.mc = mc;
    }
    public void run(){
        if(Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }
        if(Thread.currentThread().getName().equals("t2")){
            mc.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");
    }
}

死锁：

在开发中synchronized最好不要嵌套使用，一不小心就会导致死锁的产生。

以下代码中，线程一要先锁住对象o1然后再锁住对象o2才能完成任务，而线程二要先锁住对象o2然后再锁住对象o1才能完成任务。在线程一锁住o1但还未锁住o2的时候，倘若线程二锁住了o2，那么程序将无法执行下去，这种现象被称为死锁。

死锁不会报错，很难调试，只能尽量避免。

public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        // t1和t2两个线程共享o1,o2
        Thread t1 = new MyThread1(o1,o2);
        Thread 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;
    }
    public void run(){
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){

            }
        }
    }
}

class MyThread2 extends Thread {
    Object o1;
    Object o2;
    public MyThread2(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){

            }
        }
    }
}

以后开发中应该怎么解决线程安全问题？

是一上来就选择线程同步吗？不是，synchronized会让程序的执行效率降低，用户体验不好。系统的用户吞吐量（并发量）降低。用户体验差。在不得已的情况下再选择线程同步机制。

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

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

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

守护线程：

java语言中线程分为两大类：

一类是：用户线程

一类是：守护线程（后台线程），其中具有代表性的就是：垃圾回收线程（守护线程）。

守护线程的特点：

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

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

守护线程用在什么地方呢？
如系统数据自动备份，这个需要使用到定时器，我们可以将定时器设置为守护线程。一直运行，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，因为没有必要进行数据备份了。

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

定时器：

定时器的作用：

间隔特定的时间，执行特定的程序。

在java中其实可以采用多种方式实现：

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

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

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

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/*
使用定时器指定定时任务。
 */
public class TimerTest {
    public static void main(String[] args) throws Exception {

        // 创建定时器对象
        Timer timer = new Timer();    // 默认是普通线程
        //Timer timer = new Timer(true); //守护线程的方式

        // 指定定时任务
        //timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = sdf.parse("2020-03-14 09:34:30");
        //timer.schedule(new LogTimerTask() , firstTime, 1000 * 10);
        // 每年执行一次。
        //timer.schedule(new LogTimerTask() , firstTime, 1000 * 60 * 60 * 24 * 365);

        //匿名内部类方式
        timer.schedule(new TimerTask(){
            @Override
            public void run() {
                // code....
            }
        } , firstTime, 1000 * 10);

    }
}

// 编写一个定时任务类
// 假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask {

    @Override
    public void run() {
        // 编写你需要执行的任务就行了。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strTime = sdf.format(new Date());
        System.out.println(strTime + ":成功完成了一次数据备份！");
    }
}

实现线程的第三种方式：实现Callable接口（JDK8新特性）。

这种方式实现的线程可以获取线程的返回值。之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask; // JUC包下的，属于java的并发包，老JDK中没有这个包。新特性。

/*
实现线程的第三种方式：
    实现Callable接口
    这种方式的优点：可以获取到线程的执行结果。
    这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。
 */
public class ThreadTest15 {
    public static void main(String[] args) throws Exception {

        // 第一步：创建一个“未来任务类”对象。
        // 参数非常重要，需要给一个Callable接口实现类对象。
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception { // call()方法就相当于run方法。只不过这个有返回值
                // 线程执行一个任务，执行之后可能会有一个执行结果
                // 模拟执行
                System.out.println("call method begin");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;
                return a + b; //自动装箱(300结果变成Integer)
            }
        });

        // 创建线程对象
        Thread t = new Thread(task);

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

        // 这里是main方法，这是在主线程中。
        // 在主线程中，怎么获取t线程的返回结果？
        // get()方法的执行会导致“当前线程阻塞”
        Object obj = task.get();
        System.out.println("线程执行结果:" + obj);

        // main方法这里的程序要想执行必须等待get()方法的结束
        // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        // 另一个线程执行是需要时间的。
        System.out.println("hello world!");
    }
}

关于Object类中的wait和notify方法（生产者和消费者模式）：

注意：

第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。wait方法和notify方法不是通过线程对象调用。

第二：wait()方法作用？

    Object o = new Object();
    o.wait();

上述代码表示：让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。

第三：notify()方法作用？

    Object o = new Object();
    o.notify();

上述代码表示：唤醒正在o对象上等待的线程。

另外还有一个notifyAll()方法：

这个方法是唤醒o对象上处于等待的所有线程。

import java.util.ArrayList;
import java.util.List;

/*
1、使用wait方法和notify方法实现“生产者和消费者模式”

2、什么是“生产者和消费者模式”？
    生产线程负责生产，消费线程负责消费。
    生产线程和消费线程要达到均衡。
    这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。

3、wait和notify方法不是线程对象的方法，是普通java对象都有的方法。

4、wait方法和notify方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库。有线程安全问题。

5、wait方法作用：o.wait()让正在o对象上活动的线程t（调用wait()的线程）进入等待状态，
    并且释放掉t线程（调用wait()的线程）之前占有的o对象的锁。
    你陷入无休止的等待状态，就不能一直让别的线程等你们归还锁，不能占着茅坑不拉屎。

6、notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。

    notify()之后，消费者和生产者都可以抢这个锁，
    就会出现消费者消费完后继续抢到生产者的锁的情况，
    但因为加了判断，仓库为空，消费者会执行wait()方法
    依然还是会把抢来的锁还给生产者。

7、模拟这样一个需求：
    仓库我们采用List集合。
    List集合中假设只能存储1个元素。
    1个元素就表示仓库满了。
    如果List集合中元素个数是0，就表示仓库空了。
    保证List集合中永远都是最多存储1个元素。

    必须做到这种效果：生产1个消费1个。
 */
public class ThreadTest16 {
    public static void main(String[] args) {
        // 创建1个仓库对象，共享的。
        List list = new ArrayList();
        // 创建两个线程对象
        // 生产者线程
        Thread t1 = new Thread(new Producer(list));
        // 消费者线程
        Thread t2 = new Thread(new Consumer(list));

        t1.setName("生产者线程");
        t2.setName("消费者线程");

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

// 生产线程
class Producer implements Runnable {
    // 仓库
    private List list;

    public Producer(List list) {
        this.list = list;
    }
    @Override
    public void run() {
        // 一直生产（使用死循环来模拟一直生产）
        while(true){
            // 给仓库对象list加锁。
            synchronized (list){
                if(list.size() > 0){ // 大于0，说明仓库中已经有1个元素了。
                    try {
                        // 当前线程进入等待状态，并且释放Producer之前占有的list集合的锁。
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 程序能够执行到这里说明仓库是空的，可以生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                // 唤醒消费者进行消费
                list.notify();
                // 即便是list.notifyAll();也没事，因为另一个线程正卡在wait()那一行，
                // 唤醒之后本方法结束，归还锁后另一个线程得到锁开始执行本线程又在等待锁
            }
        }
    }
}

// 消费线程
class Consumer implements Runnable {
    // 仓库
    private List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        // 一直消费
        while(true){
            synchronized (list) {
                if(list.size() == 0){
                    try {
                        // 仓库已经空了。
                        // 消费者线程等待，释放掉list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 程序能够执行到此处说明仓库中有数据，进行消费。
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                // 唤醒生产者生产。
                list.notify();
                // 即便是list.notifyAll();也没事，因为另一个线程正卡在wait()那一行，
                // 唤醒之后本方法结束，归还锁后另一个线程得到锁开始执行本线程又在等待锁
            }
        }
    }
}

线程间的通信：

等待唤醒机制可用于达到线程之间的通信：

import java.util.ArrayList;
import java.util.List;

public class TestSync {
    public static void main(String[] args) {
        // 定义一个锁对象
        Object lock = new Object();
        List<String> list = new ArrayList<>();
        // 实现线程A
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                for (int i = 1; i <= 10; i++) {
                    list.add("abc");
                    System.out.println("线程A向list中添加一个元素，此时list中的元素个数为：" + list.size());
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (list.size() == 5)
                        lock.notify();// 唤醒B线程
                }
            }
        });
        // 实现线程B
        Thread threadB = new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    if (list.size() != 5) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("线程B收到通知，开始执行自己的业务...");
                }
            }
        });
        //　需要先启动线程B
        threadB.start();
        // 再启动线程A
        threadA.start();
    }
}

线程的状态：

sleep()是Thread类的一个静态方法。

wait()方法也可以传递一个long类型的参数，表示等待的毫秒数，达到的效果与sleep()方法一致。

sleep()方法不释放锁，wait()方法释放锁，其他程序可夺取该线程的锁。

wait()和notify()是Object类的一个实例方法，必须由锁对象进行调用。（任意锁对象都继承了Object类，都能调用该方法）在哪个线程中调用了wait()方法，那就哪个线程进入等待状态，当其他线程调用notify()方法后，原线程被唤醒，进入运行状态或阻塞状态。

当调用notify()方法唤醒一个线程时，该线程将继续执行wait()方法之后的代码。如果有多个线程都用同一个锁对象进入等待状态，那么在调用notify()方法唤醒线程时，将随机唤醒一个线程。

使用notifyAll()方法可以同时唤醒所有使用该锁对象进入等待状态的线程。

wait和 notify只能在同步代码块或同步方法中使用。

wait()方法会抛出一个InterruptedException异常，这个异常必须捕获，不能再声明抛出，因为run()方法并没有抛出异常，我们要重写run()方法，那就也不能抛出异常。

Lock锁：

java.util.concurrent.locks下有一个Lock接口，提供了比使用 synchronized 方法和语句更广泛的锁定操作。

Lock接口中的常用方法：

void lock(); 获取锁。

void unlock(); 释放锁。

java.util.concurrent.locks.Reentrantlock类实现了Lock接口，可直接调用。

使用步骤:

1、在可能会出现安全问题的代码外部创建一个ReentrantLock对象。

2、在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁。

3、在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁。

代码示例：

class RunnableImpl implements Runnable{
    int ticket=100;
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        lock.lock();
        while (true){
            System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
            ticket--;
            if(ticket==0){
                break;
            }
        }
        lock.unlock();
    }
    
}

特别的，可以把unlock方法放到finally语句中，这样无论其中的语句是否出现异常，都会释放锁，保证了下一个线程可以执行。

class RunnableImpl implements Runnable{
    int ticket=100;
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        lock.lock();
        try {
            while (true){
                System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
                ticket--;
                if(ticket==0){
                    break;
                }
            }
        }finally {
            lock.unlock();    
        }
    }

}

线程池：

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。

那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务?

在Java中可以通过线程池来达到这样的效果。

线程池的实现方法：

当程序第一次启动的时候创建多个线程保存到一个集合中，如LinkedList<Thread>，当我们想要使用线程的时候，就可以从集合中取出来线程使用：

Thread t = list.remove(0);        // 返回的是被移除的元素(线程只能被一个任务使用)

当我们使用完毕线程,需要把线程归还给线程池：

list.add(t);

合理利用线程池能够带来好处：

1、降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务

2、提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

3、提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存而把服务器累趴下（每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机）。

在JDK1.5之后，Java中已经内置了一个线程池，我们可以直接使用。

Java内置线程池的使用：

java.util.concurrent 包下有一个 Executors 类，是线程池的工厂类，用来生成线程池。

Executors 类中的静态方法：

static ExecutorService newFixedThreadPool(int nThreads); 创建一个可重用固定线程数的线程池。

参数： int nThreads，创建线程池中包含的线程数量。
返回值： ExecutorService接口，返回的是ExecutorService接口的实现类对象。我们可以使用ExecutorService接口接收（面向接口编程）

java.util.concurrent.ExecutorService：线程池接口。内置有用来从线程池中获取线程的方法。

submit(Runnable task); 提交一个 Runnable 的实现类对象给线程池，让线程池中的一个线程按照实现类的代码执行任务。

void shutdown(); 用于执行关闭/销毁线程池的方法。

以上方法均是用工厂方法返回的ExecutorService类的对象进行调用。

线程池的使用步骤：

1、使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池。

2、创建一个类，实现Runnable接口，重写run方法，设置线程任务。

3、把Runnable的一个实现类对象作为实参调用ExecutorService中的submit()方法，传递线程任务，开启线程，执行实现类的run方法。

4、调用ExecutorService中的方法shutdown销毁线程池(不建议执行)。

注意：

1、线程池的线程执行完Runnable实现类的run()方法后，会自动返回线程池中。当线程池中的线程数不足以支撑所有的线程调用时，线程的调用会等待，等待一个完成了任务的线程返回线程池中，再用该线程执行新任务。

2、线程池会一直在执行，代码不会停止，如果想让代码停止，须调用shutdowm()方法。线程池销毁后如果继续调用线程池的submit()方法会抛出一个异常。

代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo {
    public static void main(String[] args) {
        ExecutorService ex = Executors.newFixedThreadPool(2);
        ex.submit(new ESimpl());
        ex.submit(new ESimpl());
        ex.submit(new ESimpl());
        ex.shutdown();

    }
}

class ESimpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"正在执行任务");
    }
}