java|Java线程笔记 java|多线程

java线程

一、多线程概述
- *1.1 什么是进程？什么是线程？*
- *1.2 进程和线程是什么关系？*
- *1.3 堆和方法区共享，栈独立*
- *1.4 多线程并发的理解*
二、java实现线程的三种方式
- *2.1 方式一：继承Thread类*
- *2.2 方式二：实现Runnable接口*
- *2.3 方式三：实现Callable接口*
三、Thread类
- 3.1 线程的生命周期
- *3.2 Thread类的常用方法*
- - 获取当前线程对象
  - 获取线程对象的名字
  - 修改线程对象的名字
  - 关于线程的sleep方法
  - 终止线程睡眠
  - 合理终止线程
- *3.3 线程调度（了解*）
- - 常见的线程调度模型
  - 与线程调度有关的方法
四、线程安全（重要）
- *4.1 线程安全概述*
- *4.2 synchronized关键字*
- - 对synchronized的理解
  - synchronized的三种写法
  - 死锁
  - 哪些变量有线程安全问题
  - 以后在开发中应该如何解决线程安全问题？
五、与线程相关的其他内容
- *5.1 守护线程*
- *5.2 定时器*
- *5.3 关于Object类中的wait和notify方法。（生产者和消费者模式！）*

一、多线程概述 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 多线程并发的理解

对于单核的CPU来说，真的可以做到真正的多线程并发吗？
对于多核的CPU电脑来说，真正的多线程并发是没问题的。4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。
【java|Java线程笔记】什么是真正的多线程并发？
多个线程之间，互不干扰，各自执行各自的，这就是真正的多线程并发。
单核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)

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

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 线程调度（了解）常见的线程调度模型

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

与线程调度有关的方法

线程的优先级

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)

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

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

四、线程安全（重要） 4.1 线程安全概述

线程安全为什么重要？
以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。
最重要的是：你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。
什么时候数据在多线程并发的环境下会存在安全问题呢？
满足以下三个条件之后，就会存在线程安全问题：
条件1：多线程并发。
条件2：有共享数据。
条件3：共享数据有修改的行为。
怎么解决线程安全问题呢？
线程同步：用线程排队执行解决线程安全问题，实际上就是线程不能并发了，线程必须排队执行。
说到线程同步，涉及到这两个专业术语：
异步编程模型：线程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 守护线程

java语言中线程分为两大类：
用户线程：主线程main方法是一个用户线程。
守护线程（后台线程）：垃圾回收线程就是一个具有代表性的例子。
守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。
守护线程用在什么地方呢？
每天00:00的时候系统数据自动备份。这个需要使用到定时器，并且我们可以将定时器设置为守护线程。一直在那里看着，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。
守护线程的实现：

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

5.2 定时器 定时器的作用：间隔特定的时间，执行特定的程序。例如：每天要进行数据的备份操作。
在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种方式实现：

可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）
在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
在实际的开发中，目前使用较多的是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对象上等待的线程