Java多线程详解
Java多线程总结
整理一下老杜的课堂笔记
-
什么是进程，什么是线程
进程是一个应用程序，一个软件，比如QQ，微信，英雄联盟都是一个进程。线程是一个进程中的执行场景/执行单元，一个进程可以启动多个线程。比如火车站售票窗口，火车站是一个进程，每个售票窗口都是一个线程。
对于java程序来说，当在DOS命令窗口中输入：
java HelloWorld 回车之后。
会先启动JVM，而JVM就是一个进程。
JVM再启动一个主线程调用main方法。
同时再启动一个垃圾回收线程负责看护，回收垃圾。
最起码，现在的java程序中至少有两个线程并发，
一个是垃圾回收线程，一个是执行main方法的主线程。
线程和进程的关系：
进程A和进程B的内存独立不共享。魔兽游戏是一个进程,酷狗音乐是一个进程。这两个进程是独立的，不共享资源。
线程A和线程B呢？
在java语言中：
线程A和线程B，堆内存和方法区内存共享。
但是栈内存独立，一个线程一个栈。
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，
互不干扰，各自执行各自的，这就是多线程并发。
火车站，可以看做是一个进程。
火车站中的每一个售票窗口可以看做是一个线程。
我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。
所以多线程并发可以提高效率。
java中之所以有多线程机制，目的就是为了提高程序的处理效率。
-
实现线程的3种方式
第一种方式： 编写一个类，直接继承java.lang.Thread，重写run方法。
public class Test01 {
public static void main(String[] args) {
Thread myThread = new MyThread();
myThread.start();//启动线程
}
}
class MyThread extends Thread{
@Override
public void run() {
for (int i =0;i<10;i++){
System.out.println(i);
}
}
}
start()方法的作用：启动一个分支线程，在JVM种开辟一个新的栈空间，这段代码瞬间完成，线程启动成功之后会自动调用run()方法，run()方法在分支栈的底部，run()方法和main()方法是平级的。
注：直接在main()方法种调用run()方法是不会启动线程的，也不会分配新的栈空间，只是在主栈中运行run()方法而已。
第二种方式： 编写一个类，实现java.lang.Runnable接口，实现run方法。
public class Test01 {
public static void main(String[] args) {
MyThread myThread = new MyThread();//这只是一个可运行的对象，还不是一个线程
Thread t = new Thread(myThread);//将Runnable传入
t.start();//启动线程
}
}
class MyThread implements Runnable{
@Override
public void run() {
for (int i = 0;i<10;i++){
System.out.println(i);
}
}
}
注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。
第三种方式： 实现Callable接口。（JDK8新特性。）
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么能拿到这个执行结果呢？
使用第三种方式：实现Callable接口方式。
public class Test01 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyThread myThread = new MyThread();
FutureTask f = new FutureTask(myThread);//创建未来任务类对象，JUC包下的
Thread t = new Thread(f);//把未来任务类对象传入
t.start();//启动线程
Object res = f.get();//该方法能获取返回值
System.out.println(res);//45
}
}
class MyThread implements Callable {
@Override
public Object call() throws Exception {
int res = 0;
for (int i = 0;i<10;i++){
res += i;
}
return res;
}
}
注意：get()方法在主线程运行，会使得主线程受阻，get()方法是用来获取另一个线程的返回值的，但是另一个线程的执行可能需要过长的时间。
-
线程的生命周期
上老杜的图：
-
几个常用的方法
1.获取当前线程对象
Thread t = Thread.currentThread();
2.获取线程对象的名字
Thread t = Thread.currentThread();
String name = t.getName();
3.修改线程对象的名字
Thread t = Thread.currentThread();
t.setName("t1线程");
4.isAlive(),判断当前线程是否处于活动状态（线程已启动并且尚未终止）。
SubThread subThread = new SubThread();
System.out.println(subThread.isAlive()); //false
subThread.start();
System.out.println(subThread.isAlive());//这里可能true 可能 false
Thread.sleep(1000);
System.out.println(subThread.isAlive());//false
5.sleep()，让当前线程进入休眠，进入阻塞状态，放弃占有的时间片
Thread.sleep(1000);//睡眠一秒
面试题：问下面程序是否能让t线程进入睡眠？
public class Test01 {
public static void main(String[] args) {
Thread t = new MyThread();
t.setName("t");
t.start();
try {
t.sleep(1000);//是否能让t线程进入休眠
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0;i<10;i++){
System.out.println(i);
}
}
}
答：不会，sleep()是静态方法，只会让当前线程进入休眠。
6.终止线程的休眠。interrupt()方法。注意，这个方法依靠的是java的异常处理机制，这个方法执行的时候会让slee()报异常，使程序进入catch语句块，使得sleep()方法结束。
public class Test01 {
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
t.interrupt();//终止休眠
}
}
class MyThread extends Thread {
@Override
public void run() {
try {
Thread.sleep(1000*60*60*24*365);//休眠一年
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0;i<10;i++){
System.out.println(i);
}
}
}
该方法也可以用来中断线程，单独使用该方法仅仅是在当前线程打一个中断标志，并不是真正的停止线程。
我们需要用一下的方式来中断线程
*** 使用该方法也可以让线程中断wait(),并抛出异常。
7.getId(); thread.getId()可以获得线程的唯一标识。
注意：某个编号的线程运行结束之后，该编号可能被后续创建的线程使用。
Thread t = new MyThread();
System.out.println(t.getId()); //获取线程编号
-
强行终止一个线程
stop()方法，但是这个方法容易丢失数据，不建议使用。已经过时了。
Thread t = new MyThread();
t.start();
t.stop();//强行终止
合理终止一个线程的执行：打一个布尔标记就可以了。
public class Test01 {
public static void main(String[] args) throws InterruptedException {
MyThread m = new MyThread();
Thread t = new Thread(m);
t.start();
Thread.sleep(1000*5);//模拟5秒后终止线程
m.run = false;//终止线程
}
}
class MyThread implements Runnable {
boolean run = true;
@Override
public void run() {
for (int i = 0;i<10;i++){
if (run){
System.out.println(i);
}else {
//可以在return之前保存数据
return;
}
}
}
}
-
线程的调度（了解内容）
1、常见的线程调度模型有哪些？
抢占式调度模型：
那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
java采用的就是抢占式调度模型。
均分式调度模型：
平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
平均分配，一切平等。
有一些编程语言，线程调度模型采用的是这种方式。
2、java中提供了哪些方法是和线程调度有关系的呢？
实例方法：
void setPriority(int newPriority) 设置线程的优先级
int getPriority() 获取线程优先级
最低优先级1
默认优先级是5
最高优先级10
优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）并不是优先级高的抢到时间片的几率大。
线程的优先级具有继承性，在A线程中创建了B线程，则B线程的优先级与A线程一样。
t.setPriority(10);//设置优先级为10
int i = t.getPriority();//获取优先级
静态方法：
static void yield() 让位方法
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注意：在回到就绪之后，有可能还会再次抢到。
Thread.yield();
实例方法：
void join() 合并线程：这个方法不是栈的合并，而是栈互相之间发生了等待。
MyThread m = new MyThread();
Thread t = new Thread(m);
t.start();
t.join();//当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
for (int i = 0;i<10;i++){
System.out.println("main");
}
-
多线程并发环境下，数据的安全问题
1、什么时候数据在多线程并发的环境下会存在安全问题呢？
三个条件：
条件1：多线程并发。
条件2：有共享数据。
条件3：共享数据有修改的行为。
满足以上3个条件之后，就会存在线程安全问题。
2、怎么解决线程安全问题呢？
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
线程排队执行。（不能并发）。
用排队执行解决线程安全问题。
这种机制被称为：线程同步机制。
专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。
3、怎么解决线程安全问题呀？
使用“线程同步机制”。
线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。
4、同步编程模型和异步编程模型
异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，
谁也不需要等谁，这种编程模型叫做：异步编程模型。
其实就是：多线程并发（效率较高。）
异步就是并发。
同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行
结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，
两个线程之间发生了等待关系，这就是同步编程模型。
效率较低。线程排队执行。
同步就是排队。
5、Java中有三大变量？【重要的内容。】
实例变量：在堆中。
静态变量：在方法区。
局部变量：在栈中。
以上三大变量中：
局部变量永远都不会存在线程安全问题。
因为局部变量不共享。（一个线程一个栈。）
局部变量在栈中。所以局部变量永远都不会共享。
实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。
局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。
6.线程同步机制的语法（三种）：
第一种：同步代码块，找的是对象锁
灵活
synchronized(线程共享对象){
同步代码块;
}
第二种：在实例方法上使用synchronized，找的是对象锁
表示共享对象一定是this
并且同步代码块是整个方法体。
第三种：在静态方法上使用synchronized
表示找类锁。
类锁永远只有1把。
就算创建了100个对象，那类锁也只有一把。
对象锁：1个对象1把锁，100个对象100把锁。
（我们经常会使用this或者自定义常量作为对象锁。）
类锁：100个对象，也可能只是1把类锁。
注：如果线程在执行过程中出现异常，会讲锁释放，后面等待的线程
就能拿到锁执行代码。
死锁 ：
public class Test01 {
public static void main(String[] args) throws InterruptedException {
Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new Thread(new MyThread(o1,o2));
Thread t2 = new Thread(new MyThread2(o1,o2));
t1.start();
t2.start();
}
}
class MyThread implements Runnable {
Object o1;
Object o2;
public MyThread(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 implements Runnable{
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){
}
}
}
}
我们以后开发中应该怎么解决线程安全问题？
是一上来就选择线程同步吗？synchronized
不是，synchronized会让程序的执行效率降低，用户体验不好。
系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
线程同步机制。
第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样
实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，
对象不共享，就没有数据安全问题了。）
第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候
就只能选择synchronized了。线程同步机制。
-
守护线程
java语言中线程分为两大类： 一类是：用户线程 一类是：守护线程（后台线程） 其中具有代表性的就是：垃圾回收线程（守护线程）。 守护线程的特点： 一般守护线程是一个死循环，所有的用户线程只要结束， 守护线程自动结束。 注意：主线程main方法是一个用户线程。 守护线程用在什么地方呢？ 每天00:00的时候系统数据自动备份。 这个需要使用到定时器，并且我们可以将定时器设置为守护线程。 一直在那里看着，没到00:00的时候就备份一次。所有的用户线程 如果结束了，守护线程自动退出，没有必要进行数据备份了。
t.setDaemon(true);//启动线程之前，用该代码能将线程设置为守护线程
t.start();
-
定时器
定时器的作用： 间隔特定的时间，执行特定的程序。 每周要进行银行账户的总账操作。 每天要进行数据的备份操作。 在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的， 那么在java中其实可以采用多种方式实现： 可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行 任务。这种方式是最原始的定时器。（比较low） 在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。schedule()方法能完成定时器。 不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持 定时任务的。 在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架， 这个框架只要进行简单的配置，就可以完成定时器的任务。
public class Test01 {
public static void main(String[] args) throws InterruptedException, ParseException {
Timer timer = new Timer();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date firstTime = sdf.parse("2020-10-29 20:00:00");
timer.schedule(new LogTimerTask(),firstTime,1000*5);//5秒执行一次
}
}
class LogTimerTask extends TimerTask{
@Override
public void run() {
System.out.println(1);
//编写需要进行的任务就行了
}
}
-
关于Object类中的wait和notify方法。（生产者和消费者模式！）
-
这两个方法需要放在同步代码块中，否则会产生IlleaglMonitorStateException异常
第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象 都有的方法，因为这两个方式是Object类中自带的。 wait方法和notify方法不是通过线程对象调用， 不是这样的：t.wait()，也不是这样的：t.notify()..不对。 第二：wait()方法作用？ Object o = new Object(); o.wait(); 表示： 让正在o对象上活动的线程进入等待状态，无期限等待， 直到被唤醒为止。 o.wait();方法的调用，会让“当前线程（正在o对象上 活动的线程）”进入等待状态。 第三：notify()方法作用？ Object o = new Object(); o.notify(); 表示： 唤醒正在o对象上等待的线程。 还有一个notifyAll()方法： 这个方法是唤醒o对象上处于等待的所有线程。
使用 wait和notify方法实现生产者和消费者模式
public class Test01 {
public static void main(String[] args) {
List list = new ArrayList();
Thread producer = new Producer(list);
Thread consumer = new Consumer(list);
producer.start();
consumer.start();
}
}
class Producer extends Thread{
private List list;
public Producer(List list) {
this.list = list;
}
@Override
public void run() {
while (true){
synchronized (list){
if (list.size()>0){
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
list.add(new Object());
System.out.println("生产一个");
list.notify();
}
}
}
}
}
class Consumer extends Thread{
private List list;
public Consumer(List list) {
this.list = list;
}
@Override
public void run() {
while (true){
synchronized (list){
if (list.size()==0){
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
list.remove(0);
System.out.println("消费一个");
list.notify();
}
}
}
}
}
关于wait和notify为什么一定要放在synchronized中，详细可以参考：https://blog.csdn.net/ssH18868325485/article/details/109344720