Java封神路之多线程（第一篇），从把握整体架构到具体演示，快速掌握多线程机制
目录
多线程概述
1、什么是进程？什么是线程？
- 进程是一个应用程序（1个进程是一个软件）
- 线程是一个进程中的执行场景/执行单元
- 一个进程可以启动多个线程
2、java程序中的线程
- 对于java程序员来说，当在DOS命令窗口中输入：java HelloWorld 回车之后，会先启动JVM，而JVM就是一个进程
- JVM再启动一个主线程调用main方法
- 再启动一个垃圾回收线程负责看护，回收垃圾
- 最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程
3、进程和线程是什么关系？
- 举个例子
- 阿里巴巴是一个进程，马云：阿里巴巴的一个线程，童文红：阿里巴巴的一个线程
- 京东是一个进程，强东是京东的一个线程，妹妹是京东的一个线程
- 进程可以看做是现实生活当中的公司，线程可以看做是公司当中的某个员工
- 注意：
进程A和进程B的内存独立不共享（例如阿里巴巴和京东的资源不会共享！）
魔兽游戏是一个进程
酷狗音乐是一个进程
这两个进程是独立的，不共享资源- 线程A和线程B呢？
在java语言中:
线程A和线程B，堆内存和方法区内存共享
但是栈内存独立，一个线程一个栈- 假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。例如火车站，可以看做是一个进程，火车站中的每一个售票窗口可以看做是一个线程，我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你，所以多线程并发可以提高效率
- java中之所以有多线程机制，目的就是为了提高程序的处理效率
4、多线程机制下的main方法
- 使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束?
main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈5、真正的多线程并发是什么？
- 分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？
对于多核的CPU电脑来说，真正的多线程并发是没问题的
4核CPU表示同一个时间点上，可以真正的有4个进程并发执行- 但是对于单核的CPU，不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉，对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，给人来的感觉是：多个事情同时在做！！！！！
线程A：播放音乐
线程B：运行魔兽游戏
线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，给我们的感觉是同时并发的- 电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，
人类的眼睛产生了错觉，感觉是动画的，这说明人类的反应速度很慢，就像
一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在
这个期间计算机可以进行亿万次的循环，因为计算机的执行速度很快- 所以什么是真正的多线程并发？
t1线程执行t1的
t2线程执行t2的
t1不会影响t2，t2也不会影响t1—多线程并发6、实现线程的两种方式
- java支持多线程机制，并且java已经将多线程实现了，我们只需要继承就行
第一种方式：编写一个类，直接继承java.lang.Thread，需要重写run方法// 定义线程类 public class MyThread extends Thread{ public void run(){ } } // 创建线程对象 MyThread t = new MyThread(); // 启动线程 t.start();
- 第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法
// 定义一个可运行的类 public class MyRunnable implements Runnable { public void run(){ } } // 创建线程对象 Thread t = new Thread(new MyRunnable()); // 启动线程 t.start();
- 注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活
7、怎么获取当前线程对象
- 获取当前线程对象：static Thread currentThread();
- 获取线程对象的名字：String name=线程对象.getName();
- 修改线程对象的名字：线程对象.setName("线程名字");
8、关于线程对象的生命周期？
- 新建状态
就绪状态
运行状态
阻塞状态
死亡状态9、了解——关于线程的调度
- 9.1、常见的线程调度模型有哪些？
抢占式调度模型：
那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些
java采用的就是抢占式调度模型
均分式调度模型：
平均分配CPU时间片，每个线程占有的CPU时间片时间长度一样
平均分配，一切平等
有一些编程语言，线程调度模型采用的是这种方式- 9.2、java中提供了哪些方法是和线程调度有关系的呢？
- 实例方法：
void setPriority(int newPriority) 设置线程的优先级
int getPriority() 获取线程优先级
最低优先级1
默认优先级是5
最高优先级10
优先级比较高的获取CPU时间片可能会多一些（但也不完全是，大概率是偏向优先级比较高的）- 静态方法：
static void yield() 让位方法，暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法，让当前线程让位，让给其它线程使用
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”
注意：在回到就绪状态之后，有可能会再次抢到时间片实例方法： void join()————合并线程 class MyThread1 extends Thread { public void doSome(){ MyThread2 t = new MyThread2(); t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束，当前线程才可以继续，两个栈之间发生了等待关系 }* } class MyThread2 extends Thread{ }10、关于多线程并发环境下，数据的安全问题 （重点）
- 10.1、为什么这个是重点？
以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了，这些代码我们都不需要编写
最重要的是：你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的（重点：*****）
10.2、什么时候数据在多线程并发的环境下会存在安全问题呢？
三个条件：
条件1：多线程并发
条件2：有共享数据
条件3：共享数据有修改的行为
满足以上3个条件之后，就会存在线程安全问题10.3、怎么解决线程安全问题呢？
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？答案是：线程排队执行，不能并发，这种机制被称为：线程同步机制，专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行
线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率，数据不安全，没有效率的事儿10.4、说到线程同步这块，涉及到这两个专业术语：
（1）异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型其实就是：多线程并发（效率较高），异步就是并发
（2）同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束。两个线程之间发生了等待关系，这就是同步编程模型，效率较低，线程排队执行，同步就是排队11、Java中的三大变量是否存在线程安全问题？【重要内容】
- 实例变量：在堆中
静态变量：在方法区
局部变量：在栈中- 以上三大变量中：
局部变量永远都不会存在线程安全问题
因为局部变量不共享（一个线程一个栈）
局部变量在栈中，所以局部变量永远都不会共享
实例变量在堆中，堆只有1个
静态变量在方法区中，方法区只有1个
堆和方法区都是多线程共享的，所以可能存在线程安全问题
局部变量+常量：不会有线程安全问题
成员变量：可能会有线程安全问题12、并发环境下字符串拼接和数据存储结构的使用
- 如果使用局部变量的话：建议使用：StringBuilder
因为局部变量不存在线程安全问题，选择StringBuilder
StringBuffer效率比较低- ArrayList是非线程安全的
Vector是线程安全的
HashMap HashSet是非线程安全的
Hashtable是线程安全的13、总结：synchronized的三种写法
- 第一种： 同步代码块————灵活
synchronized(线程共享对象){
同步代码块;
}- 第二种： 在实例方法上使用synchronized
表示共享对象一定是this
并且同步代码块是整个方法体- 第三种： 在静态方法上使用synchronized
表示找类锁
类锁永远只有1把
就算创建了100个对象，那类锁也只有一把- 对象锁：1个对象1把锁，100个对象100把锁
- 类锁： 100个对象，也可能只是1把类锁
14、我们以后开发中应该怎么解决线程安全问题？
- 是一上来就选择线程同步吗？synchronized
不是，synchronized会让程序的执行效率降低，用户体验不好
系统的用户吞吐量降低，用户体验差，在不得已的情况下才选择线程同步机制- 第一种方案： 尽量使用局部变量代替“实例变量和静态变量”
- 第二种方案： 如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了）
- 第三种方案： 如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized——线程同步机制
15、线程这块的其它相关内容
- 15.1、守护线程
java语言中线程分为两大类：
一类是：用户线程
一类是：守护线程（后台线程）
其中具有代表性的就是：垃圾回收线程—守护线程- 守护线程的特点：一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束（注意：主线程main方法是一个用户线程）
- 守护线程用在什么地方呢？
每天00:00的时候系统数据自动备份，这个需要使用到定时器，并且我们可以将定时器设置为守护线程，使其一直在那里看着，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，因为没有必要进行数据备份了- 15.2、定时器
定时器的作用：
间隔特定的时间去执行特定的程序
每周要进行银行账户的总账操作
每天要进行数据的备份操作- 在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，在java中其实可以采用多种方式实现：
- 1.可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒来，执行任务，这种方式是最原始的定时器（比较low）
- 2.在java的类库中已经写好了一个定时器：java.util.Timer(父类是Object)，可以直接拿来用，不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的
- 3.在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务
- 15.3、实现线程的第三种方式：FutureTask方式，实现Callable接口（JDK8新特性）
- 这种方式实现的线程可以获取线程的返回值，之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void
思考：
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能
会有一个执行结果，我们怎么能拿到这个执行结果呢？我们可以使用第三种方式—实现Callable接口方式- 15.4、关于Object类中的wait和notify方法（生产者和消费者模式！）
第一：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对象上处于等待的所有线程
具体方法演示
1.实现线程的第一种方式
主线程任务和分支线程任务演示
package com.java.javase.Thread; public class ThreadTest01 { public static void main(String[] args) { MyThread myThread=new MyThread(); /** * start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间结束 * 这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开辟出来，start()方法就结束了，线程启动成功 * 启动成功的线程会自动调用run()方法，并且run()方法在分支栈的栈底部 * run()方法在分支栈的栈底部，main()方法在主栈的栈底部，run()方法和main()方法是平级的 * 如果是使用myThread.run()这种方式 不会启动线程，不会分配新的分支栈 */ myThread.start(); for(int i=0;i<100;i++){ System.out.println("主线程任务——"+i); } } } class MyThread extends Thread{ // 继承Thread不能再继承别的类 @Override public void run() { for(int i=0;i<100;i++){ System.out.println("分支线程任务——"+i); } } }运行结果：
主线程任务——0
分支线程任务——0
主线程任务——1
分支线程任务——1
分支线程任务——2
分支线程任务——3
分支线程任务——4
分支线程任务——5
分支线程任务——6
分支线程任务——7
分支线程任务——8
分支线程任务——9
分支线程任务——10
分支线程任务——11
分支线程任务——12
分支线程任务——13
分支线程任务——14
分支线程任务——15
分支线程任务——16
分支线程任务——17
分支线程任务——18
分支线程任务——19
主线程任务——2
分支线程任务——20
主线程任务——3
分支线程任务——21
主线程任务——4
2.实现线程的第二种方式
第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法
package com.java.javase.Thread; public class ThreadTest02 { public static void main(String[] args) { /* Myrunnable r = new Myrunnable(); Thread t = new Thread(r); t.start(); */ 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); } } }改进：换成匿名内部类编写
package com.java.javase.Thread; // 采用匿名内部类编写 public class ThreadTest03 { public static void main(String[] args) { Thread t=new Thread(new Runnable() { @Override public void run() { for(int i=0;i<100;i++){ System.out.println("分支线程——"+i); } } }); t.start(); for(int i=0;i<100;i++){ System.out.println("主线程——"+i); } } }
3.关于线程对象的名字
package com.java.javase.Thread; // 1.获取当前线程对象 // 2.获取线程对象的名字 // 3.修改线程对象的名字 public class ThreadTest04 { public static void main(String[] args) { Thread currentThread=Thread.currentThread(); // 获取主线程对象的名字 System.out.println(currentThread.getName()); MyThread t=new MyThread(); // 设置线程对象的名字 t.setName("tttt"); // 获取线程对象的名字 System.out.println(t.getName()); // 启动线程 t.start(); } } class MyThread extends Thread{ @Override public void run() { for(int i=0;i<100;i++){ System.out.println("分支线程任务——"+i); } } }
4.获取当前线程
Thread currentThread=Thread.currentThread(); System.out.println(currentThread.getName());
5.线程的sleep方法
- 关于线程的sleep方法
- static void sleep(long millis) 抛出中断异常 InterruptedException
- 参数毫秒
- 作用:让当前线程陷入休眠，进入“阻塞状态”，放弃占有的CPU时间片，让给其他线程使用
// 间隔特定的时间去执行特定的代码，每隔多久执行一次
// 这行代码出现在A线程中，A线程就会进入休眠状态
// 这行代码出现在B线程中，B线程就会进入休眠状态package com.java.javase.Thread; public class ThreadTest05 { public static void main(String[] args) { try{ Thread.sleep(1000*5); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println("hello world!"); } }面试题踩坑：
package com.java.javase.Thread; public class ThreadTest06 { public static void main(String[] args) { Thread t=new myThread(); t.setName("java"); t.start(); try{ t.sleep(1000*5); // 在执行的时候还是会转换成Thread.sleep(1000*5); }catch(InterruptedException e){ // 这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠 e.printStackTrace(); // 这行代码出现在main方法中，main线程睡眠 } System.out.println("hello world!"); // 5s之后输出 } } class myThread extends Thread{ public void run(){ for(int i=0;i<10;i++){ System.out.println(Thread.currentThread().getName()+"---"+i); } } }
6.中断线程的睡眠
package com.java.javase.Thread; // 怎么叫醒一个正在睡眠的线程，中断线程的睡眠? public class ThreadTest07 { public static void main(String[] args) { Thread t=new Thread(new MyRunnable()); t.start(); try{ Thread.sleep(1000*10); }catch(InterruptedException e){ e.printStackTrace(); } t.interrupt(); } } class MyRunnable 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); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"---over"); } }
7.stop方法—强行终止线程，直接将线程杀死（容易丢失数据）
那么怎样合理的终止一个线程呢？通过设置布尔标记
package com.java.javase.Thread; /** * 怎么合理的终止一个线程的执行？ */ public class ThreadTest { public static void main(String[] args) { MyRunable r=new MyRunable(); Thread t=new Thread(r); t.setName("t"); t.start(); // 模拟5秒 try{ Thread.sleep(5000); }catch(InterruptedException e){ e.printStackTrace(); } // 终止线程 r.run=false; } } class MyRunable 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; } } } }
216
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
