Java线程笔记

一、多线程概述

1.1 什么是进程？什么是线程？

进程是一个应用程序（1个进程是一个软件）。
线程是一个进程中的执行场景/执行单元。
一个进程可以启动多个线程。

• 例子：

  对于java程序来说，当在DOS命令窗口中输入：java HelloWorld回车之后。会先启动JVM，而JVM就是一个进程，JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。

1.2 进程和线程是什么关系？

• 举个例子：
  进程可以看做是现实生活当中的公司。 线程可以看做是公司当中的某个员工。
• 注意：
  两个进程之间的内存独立，资源不共享。

1.3 堆和方法区共享，栈独立

在java语言中，对多个线程来说，堆内存和方法区内存共享。但是栈内存独立，一个线程一个栈。假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。java中之所以有多线程机制，就是为了提高程序的处理效率。

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

1.4 多线程并发的理解

1. 对于单核的CPU来说，真的可以做到真正的多线程并发吗？

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

2. 什么是真正的多线程并发？

   多个线程之间，互不干扰，各自执行各自的，这就是真正的多线程并发。

3. 单核CPU不能做到真正的多线程并发

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

二、java实现线程的三种方式

java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。

2.1 方式一：继承Thread类

编写一个类，直接继承java.lang.Thread，重写run方法。

// 定义线程类
class MyThread extends Thread {
    @Override
   	public void run() {
    	for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}
	
public class ThreadTest {
	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("主线程--->" + i);
        }
    }
}

run()和start（）

2.2 方式二：实现Runnable接口

编写一个类，实现java.lang.Runnable接口，实现run方法。

// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
public class MyRunnable implements Runnable {
	public void run(){
		for(int i = 0; i < 100; i++){
            System.out.println("分支线程--->" + i);
        }
	}
}

public class ThreadTest {
    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);
        }
    }
}

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

2.3 方式三：实现Callable接口

FutureTask方式，实现Callable接口。
这种方式的优点：可以获取到线程的执行结果。
这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。

class MyCallable implements 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)
    }
}
public class ThreadTest15 {
    public static void main(String[] args) throws Exception {

        // 第一步：创建一个“未来任务类”对象。
        // 参数非常重要，需要给一个Callable接口实现类对象。
        FutureTask task = new FutureTask(new MyCallable());

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

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

        // 这里是main方法，这是在主线程中。
        // 在主线程中，怎么获取t线程的返回结果？
        // get()方法的执行会导致“当前线程阻塞”
        Object obj = task.get();
        
        // main方法这里的程序要想执行必须等待get()方法的结束
        // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        // 另一个线程执行是需要时间的。
        System.out.println("线程执行结果:" + obj);
        System.out.println("hello world!");
    }
}

三、Thread类

3.1 线程的生命周期

3.2 Thread类的常用方法

获取当前线程对象

    Thread t = Thread.currentThread();
    返回值t就是当前线程。

获取线程对象的名字

    String name = 线程对象.getName();

修改线程对象的名字

    线程对象.setName("线程名字");

当线程没有设置名字的时候，默认的名字有什么规律？（了解一下）

        Thread-0
        Thread-1
        Thread-2
        Thread-3
        .....

关于线程的sleep方法

static void sleep(long millis)

1. 静态方法：Thread.sleep(1000);
2. 参数是毫秒，指定线程睡眠的时间。
3. 作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。可实现间隔特定的时间，去执行一段特定的代码。
4. 思考题：

public class ThreadTest07 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.setName("t");
        t.start();

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

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

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

终止线程睡眠

void interrupt()

// 终断t线程的睡眠（这种终断睡眠的方式依靠了java的异常处理机制。）
t.interrupt(); // 干扰，一盆冷水过去！

合理终止线程

在java中强行终止一个线程的执行： 调用stop（）方法
这种方式存在很大的缺点：容易丢失数据。因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用。

合理的终止线程：
在自定义的线程类中打一个布尔标记，你想要什么时候终止线程的执行，把标记修改为false，线程就结束了。

class MyRunable4 implements Runnable {

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

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            if(run0){
                //这里可以写执行的代码
            }else{
                // return就结束了，你在结束之前还有什么没保存的。
                // 在这里可以保存呀。
                //save....

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

3.3 线程调度（了解）

常见的线程调度模型

1. 抢占式调度模型
   哪个线程的优先级较高，哪个抢到的CPU时间片的概率就高一些。
   java采用的就是抢占式调度模型。
2. 均分式调度模型
   平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样，平均分配，一切平等。有一些编程语言，线程调度模型采用的是这种方式。

与线程调度有关的方法

1. 线程的优先级

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

//获取线程优先级：    int getPriority()
//设置线程的优先级：  void setPriority(int newPriority)

2. 让位方法
   静态方法：Thread.yield()
   暂停当前正在执行的线程对象，回到就绪状态，并执行其他线程。
   yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
   yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。注意：在回到就绪之后，有可能还会再次抢到。

3. 合并线程
   void join() 方法

   t.join(); 
   // t合并到当前线程中，当前线程受阻塞，t线程执行，直到t线程结束，当前线程才可以继续。
   

四、 线程安全（重要）

4.1 线程安全概述

1. 线程安全为什么重要？

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

   最重要的是：你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。

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

   满足以下三个条件之后，就会存在线程安全问题：
   条件1：多线程并发。
   条件2：有共享数据。
   条件3：共享数据有修改的行为。

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

   线程同步：用线程排队执行解决线程安全问题，实际上就是线程不能并发了，线程必须排队执行。

4. 说到线程同步，涉及到这两个专业术语：

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

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

4.2 synchronized关键字

对synchronized的理解

在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁。）
线程t1在遇到synchronized关键字后，会自动在锁池中找共享对象a的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的，直到同步代码块代码结束，这把锁才会释放。此时其他共享此对象a的线程t2需等待t1的结束，才能有机会获取对象a的对象锁，这样就达到了线程排队执行。

synchronized的三种写法

1. 同步代码块：灵活

synchronized(线程共享对象){
		同步代码块;
}

synchronized后面小括号中传的这个“数据”是相当关键的。这个数据必须是多线程共享的数据，才能达到多线程排队。你想让哪些线程同步，就在小括号中填入这些线程共享的对象。

2. 在实例方法上使用synchronized： 不灵活但简洁
synchronized出现在实例方法上，一定锁的是this。没得挑，只能是this。不能是其他的对象了，所以这种方式不灵活。
另外还有一个缺点：synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低，所以这种方式不常用。
3. 在静态方法上使用synchronized： 表示找类锁
类锁永远只有1把，就算创建了100个对象，那类锁也只有1把。
对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只是1把类锁。

死锁

死锁代码：

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在开发中最好不要嵌套使用，容易导致死锁。

哪些变量有线程安全问题

Java中有三大变量：

实例变量：在堆中。

静态变量：在方法区。

局部变量：在栈中。

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

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

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

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

以后在开发中应该如何解决线程安全问题？

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

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

第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了，线程同步机制。synchronized会让程序的执行效率降低，系统的用户吞吐量降低，用户体验差。在不得已的情况下再选择线程同步机制。

五、与线程相关的其他内容

5.1 守护线程

1. java语言中线程分为两大类：
   用户线程 ：主线程main方法是一个用户线程。
   守护线程（后台线程）：垃圾回收线程就是一个具有代表性的例子。

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

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

4. 守护线程的实现：

   // 启动线程之前，将线程设置为守护线程（调用setDaemon方法，传入ture值）
   线程对象.setDaemon(true);
   

5.2 定时器

定时器的作用： 间隔特定的时间，执行特定的程序。 例如：每天要进行数据的备份操作。

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

1. 可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）
2. 在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
3. 在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。而SpringTask框架的底层实现原理就是java.util.Timer

/*
使用定时器指定定时任务。
 */
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);

// 编写一个定时任务类
// 假设这是一个记录日志的定时任务
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 + ":成功完成了一次数据备份！");
    }
}

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

wait和notify方法不是线程对象的方法，是Object类中自带的，是普通java对象都有的方法。wait方法和notify方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库，有线程安全问题。

wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。

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

notifyAll()方法作用：o.notifyAll()唤醒所有正在o对象上等待的线程