——————————————————————————————
笔记
————————————
- 线程睡眠/阻塞:用
TimeUnit.SECONDS.sleep()
取代Thread.sleep()
import java.util.concurrent.TimeUnit;
try {
//Thread.sleep(10*1000); 等价于
TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
为什么说他好呢?因为他更灵活:
TimeUnit.SECONDS.sleep();
TimeUnit.MINUTES.sleep();
TimeUnit.HOURS.sleep();
TimeUnit.DAYS.sleep();
————————————
————————————
————————————
————————————
————————————
——————————————————————————————
通俗地说:
进程:比如IDEA或者QQ的运行,是程序(任务)的执行过程,持有资源(共享内存、共享文件)和线程;
(说明是动态性的,单个文件并不是进程,只有点击文件使程序运行后才发生进程)
(进程是资源、线程的载体,脱离了线程谈进程无意义)
线程:比如QQ中的“文字聊天”“收发文件”,所有这些人物都可以理解为线程;
线程的交互:互斥与同步;比方说进程是班级,线程是学生,学生沟通就是线程,学生之间有时需要合作(同步)才能达到目的,有时需要竞争(互斥)才能达到目的;
——————————————————————————————
- 程序、进程、线程的区别是什么?分别举例说明 (初中级面试)
程序是进程的超集,进程是线程的超集;(一个程序可以有多个进程,一个进程可以有多个线程)
- 程序 Program:是一个指令的集合。程序不能独立执行,只有被加载到内存中,系统为他分配资源后才能执行;
- 进程 Process:如上,一个执行中的程序叫做进程;
进程是系统分配资源的独立单位,每个进程在系统内顺序执行的特定地址;
程序是进程的静态文本描述,进程是程序在系统内顺序执行的动态活动; - 线程 Thread:是进程的“单一的连续控制流程”;
线程是CPU调度和分配的基本单位,是比进程更小的,能独立运行的基本单位,也被称作轻量级的进程;
能独立运行,但不能独立存在;
线程不能独立存在,必须依附于某个进程;一个进程可以包括多个并行的线程,一个线程肯定属于一个进程;
Java允许并发执行多个线程;
例如:一个车间是一个程序,一个正在进行生产任务的车间是一个进程,车间内每个从事不同工作的工人是一个线程;
——————————————————————————————
Java对线程的支持体现在:
Thread类
和 Runnable接口
之上,他们都继承于java.lang包;
他们之间共通的方法是run()
,此方法为我们提供了线程执行的代码;
Thread.activeCount()
返回活动线程的【当前线程】的线程组中的【数量】
注意!若实际只运行了1个线程时,其他IDE中此方法返回的是1
;
但IDEA中使用此方法返回的是2
,因为IDEA中多了个Monitor Ctrl-Break
监控线程,使用IDEA时注特别注意!!!!!!!!
————————————————————————
多线程
提问:实现多线程的方式?
1.继承Thread
类创建线程;
2.实现Runnable
接口创建线程;
(答出1、2点就够了;下面是两种特殊的方式,不用死记硬背,不重要)
3.实现Callable
接口,通过FutureTask包装器来创建Thread线程;(少用)
4.使用ExecutorService
、Callable
、Future
实现由返回结果的线程;(线程池)(少用)
注:两者获取线程名称的方式有区别
Thread
类用:getName()
Runnable
接口用:Thread.currentThread().getName()
1.继承Thread类创建线程;
(写两个线程)
public class Test1 extends Thread{
public void run(){
System.out.println("Test1.run()");
}
public static void main(String[] args) {
Test1 t1 = new Test1();
Test1 t2 = new Test1();
t1.start();
t2.start();
}
}
————————————
输出:
Test1.run()
Test1.run()
也可以简写:
public class Test1 extends Thread{
public void run(){
System.out.println("Test1.run()");
}
public static void main(String[] args) {
new Test1().start();
new Test1().start();
}
}
2.实现Runnable接口创建线程;
(写两个线程)
易错点!!!要先实例化Test类,再把实例对象放在Thread的实例语句中,不要写反!!!
public class Test2 implements Runnable {
public void run(){
System.out.println("Test2.run()");
}
public static void main(String[] args) {
Test2 t1 = new Test2();
Test2 t2 = new Test2();
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t2);
thread1.start();
thread2.start();
}
}
————————————
输出:
Test2.run()
Test2.run()
3.实现Callable
接口,通过FutureTask包装器来创建Thread线程;
public class Test3<Object> implements Callable<Object> {
public Object call(){
System.out.println(Thread.currentThread().getName()+"————我是通过Callable接口通过FutureTask包装器来实现的线程。");
return null;
}
}
public class Test2 {
// 通过Callable和FutureTask创建线程
/*
* a.创建Callable接口的实现类,并实现Call方法
* b.创建Callable实现类的实现,使用FutureTask类包装Callable对象,该FutureTask对象封装了Callable对象的Call方法的返回值
* c.使用FutureTask对象作为Thread对象的target创建并启动线程
* d.调用FutureTask对象的get()来获取子线程执行结束后的返回值
*/
public static void main(String[] args) {
Callable<Object> oneCallable = new Test3<>();
FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
Thread t = new Thread(oneTask);
System.out.println(Thread.currentThread().getName());
t.start();
}
}
————————————
输出:
main
Thread-0————我是通过Callable接口通过FutureTask包装器来实现的线程。
4.使用ExecutorService
、Callable
、Future
实现由返回结果的线程;(线程池)(少用)
public class Test4 {
// 使用`ExecutorService`、`Callable`、`Future`实现由返回结果的线程(线程池)
private static int POOL_NUM = 10; // 线程池数量
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(5);
for(int i = 0; i < POOL_NUM ; i++){
RunnableThread thread = new RunnableThread();
executorService.execute(thread);
}
executorService.shutdown();
}
}
class RunnableThread implements Runnable{
@Override
public void run() {
System.out.println("通过线程池方法创建的线程: "+Thread.currentThread().getName());
}
}
————————————
输出:
通过线程池方法创建的线程: pool-1-thread-1
通过线程池方法创建的线程: pool-1-thread-2
通过线程池方法创建的线程: pool-1-thread-3
通过线程池方法创建的线程: pool-1-thread-4
通过线程池方法创建的线程: pool-1-thread-5
通过线程池方法创建的线程: pool-1-thread-1
通过线程池方法创建的线程: pool-1-thread-2
通过线程池方法创建的线程: pool-1-thread-3
通过线程池方法创建的线程: pool-1-thread-4
通过线程池方法创建的线程: pool-1-thread-4
附:实际中常用方法:
new Thread(new Runnable(){
...
}).start();
new Thread(){...public void run()...}.start();
(本质上,实现多线程唯一的方式是实现Thread类的run()
方法;)
——————————————————————————————
- 两种Thread创建方法的区别?(
extends Thread
和implements Runnable
)
extends Thread:
(1)优点:编写简单,如果需要访问当前线程,无需使用Thread.currentThread()
方法,直接使用this
,即可获得当前线程。
(2)缺点:因为线程类已经继承了Thread类,所以不能再继承其他的父类。(因为Java的单继承)
implements Runnable:
(1)优点:线程类只是实现了Runable接口,还可以继承其他的类。在这种方式下,可以多个线程共享同一个目标对象,所以非常适合多个相同线程来处理同一份资源(指同一个Runnable对象)的情况,从而可以将CPU代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
(2)缺点:编程稍微复杂,如果需要访问当前线程,必须使用Thread.currentThread()
方法。
总结:
- Runnable方式可以避免Thread方式因为Java单继承特性带来的缺陷;
- Runnable代码可以被多个线程(Thread实例)共享,适合于多个线程处理同一资源的情况;
(建议:多采用Runnable
这种方式创建线程)
实现Runnable接口,只创建了一个类的实例,而且被多个线程共享了。因此Counter递增。而继承Thread类, 你必须为每一个线程创建不同的实例。因此每个类的实例分配了不同的内存空间,每一个有不同的Counter,它们的值相同。这意味着没有增加因为没有一个对象的引用是相同的。
什么时候用Runnable接口呢?
当你想要在一组线程中访问相同的资源时,使用Runnable接口。在这种情况下要避免使用Thread类,因为多对象的创建会占用更多的内存,会导致大的性能花费。
PS:Thread类内部实现了Runnable接口
最后,哪种方式最好用呢?
显而易见,当然是实现Runnable接口更好。
https://www.cnblogs.com/JohnTsai/p/3979482.html
———————————————
为了实践这些差别,下列模拟一个情境:
火车站有3个卖票窗口,他们一起售出3张火车票,然后输出查看这些窗口分别卖出几张票;
(注意!安全的买票程序中run方法需要加入同步 Synchronized
!!!)
(注意!安全的买票程序中run方法需要加入同步 Synchronized
!!!)
(注意!安全的买票程序中run方法需要加入同步 Synchronized
!!!)
(注意!安全的买票程序中run方法需要加入同步 Synchronized
!!!)
(注意!安全的买票程序中run方法需要加入同步 Synchronized
!!!)
extends Thread因为单线程,所以写不写无所谓;
用Thread
:
/*
* 情境:5张火车票,由3个售票窗口(3个线程)卖出
* extends Thread
*
* 卖票逻辑:当票数>0时,就可以一直卖下去;<0时则售罄
*/
class MyThread extends Thread{
private int ticketCount = 5; // 5张火车票
private String name; // 窗口名,即线程名
public MyThread(String name){
this.name = name;
}
@Override
public void run() {
while(ticketCount > 0){
ticketCount -- ; // 若还有票,则卖掉一张
System.out.println(name + " 卖了一张票,剩余票数为:"+ticketCount);
}
}
}
// 考虑接下来的线程实例名 如何和之前定义的 String name 挂上钩?
// 因为MyThread类中定义了构造器,加入了参数String name;所以在Test1类中,要把name写进线程创建参数中
public class Test1{
public static void main(String[] args) {
MyThread mt1 = new MyThread("窗口1");
MyThread mt2 = new MyThread("窗口2");
MyThread mt3 = new MyThread("窗口3");
mt1.start();
mt2.start();
mt3.start();
}
}
———————————————
输出:
窗口3 卖了一张票,剩余票数为:4
窗口2 卖了一张票,剩余票数为:4
窗口1 卖了一张票,剩余票数为:4
窗口3 卖了一张票,剩余票数为:3
窗口1 卖了一张票,剩余票数为:3
窗口2 卖了一张票,剩余票数为:3
窗口1 卖了一张票,剩余票数为:2
窗口3 卖了一张票,剩余票数为:2
窗口2 卖了一张票,剩余票数为:2
窗口3 卖了一张票,剩余票数为:1
窗口1 卖了一张票,剩余票数为:1
窗口2 卖了一张票,剩余票数为:1
窗口3 卖了一张票,剩余票数为:0
窗口1 卖了一张票,剩余票数为:0
窗口2 卖了一张票,剩余票数为:0
居然卖出了15张票,很显然这不合理;
———————————————
用Runnable
:
/*
* 情境:5张火车票,由3个售票窗口(3个线程)卖出
* implements Runnable
*
* 卖票逻辑:当票数>0时,就可以一直卖下去;<0时则售罄
*/
class MyThread2 implements Runnable{
private int ticketCount = 5;
// implements Runnable 不用定义String name,因为Thread类中有构造方法可以直接添加名字
@Override
public synchronized void run(){
while(ticketCount > 0){
ticketCount -- ;
System.out.println(Thread.currentThread().getName() + "卖了一张票,余下票数为:"+ ticketCount);
}
}
}
public class Test2 {
public static void main(String[] args) {
MyThread2 mt1 = new MyThread2();
Thread t1 = new Thread(mt1,"窗口1");
Thread t2 = new Thread(mt1,"窗口2");
Thread t3 = new Thread(mt1,"窗口3");
t1.start();
t2.start();
t3.start();
}
}
———————————————
输出:
窗口2卖了一张票,余下票数为:4
窗口3卖了一张票,余下票数为:3
窗口1卖了一张票,余下票数为:2
窗口3卖了一张票,余下票数为:0
窗口2卖了一张票,余下票数为:1
过程:
线程1启动,没有获得CPU使用权,于是等待;
线程2启动,获得了CPU使用权,于是进入run()运行;输出 窗口2卖了一张票,余下票数为:2
线程2把资源让出来了,线程3启动,获得了CPU使用权...
为什么顺序是:第四行剩下0,第五行剩下1?反过来了?
因为实际上第五行先执行,第四行后执行;
当第五行还没来得及输出时,就被第四行执行了并输出;
易错!!!
1.容易写成这样:
Test2 t1 = new Test2("窗口1");
Test2 t2 = new Test2("窗口2");
Test2 t3 = new Test2("窗口3");
Thread thd1 = new Thread(t1);
Thread thd2 = new Thread(t2);
Thread thd3 = new Thread(t3);
thd1.start();
thd2.start();
thd3.start();
2.而且容易忘记:
implements Runnable 不用定义String name,因为Thread类中有构造方法可以直接添加名字;
3.编写XX卖出了几张票时,这个窗口名!!
要用Thread.getCurrentThread().getName()
(而且!即使写了这个,也容易忘记写上getName
)
结果是很随机的,哪个线程获得了CPU使用权,谁就可以卖出一张票;
但是这个结果是合理的,一共5张票;
———————————————
回到总结:
Runnable代码可以被多个线程(Thread实例)共享,适合于多个线程处理同一资源的情况;
验证的就是多个线程处理同一资源的情况:ticketCount
是同一资源;
———————————————
分析:
Runnable中:
MyThread2是一个唯一的一个实现Runnable接口的对象,然后我们把他作为参数,传递给三个线程对象;
因此三个线程用的都是同一个Runnable对象中的代码,所以三线程共享了同个资源:ticketCount
;
Thread中:
新建了三个线程,每个线程都有自己的ticketCount
和name
和run()
(这些资源对于每个线程来说:是独立的,不是共享的)
因此三个线程各自卖了各自的五张票,共15张票;
———————————————
修改下代码?
把Runnable中:
唯一创建的Runnable对象,改成三个Runnable对象,且把这三个不同的参数传给三个不同线程,结果会不会也变成卖了15张票?(3个线程分别卖了5张票)?
public class Test2 {
public static void main(String[] args) {
MyThread2 mt1 = new MyThread2();
MyThread2 mt2 = new MyThread2();
MyThread2 mt3 = new MyThread2();
Thread t1 = new Thread(mt1,"窗口1");
Thread t2 = new Thread(mt2,"窗口2");
Thread t3 = new Thread(mt3,"窗口3");
t1.start();
t2.start();
t3.start();
}
}
果然结果如同预料,卖了15张;
——————————————————————————————
守护线程 Daemon Thread
Java线程有两类:用户线程 守护线程
-
用户线程 User Thread:
运行在【前台】(看得清、摸不到),【执行具体任务】;
程序的主线程、连接网络的字线程等都是用户线程; -
守护线程 Daemon Thread: (顾名思义,某些线程的守护者)
运行在【后台】,为【其他前台线程】服务;
特点:
一旦所有用户线程都结束运行,守护线程就会随着JVM一起结束工作(要守护的对象都消失了,他觉得自己没有存在的必要了);
应用:
数据库连接池中的监控线程;JVM虚拟机启动后的监控线程;
(如:监测连接池的线程个数,超时时间;监测虚拟机的使用情况、锁持有的情况)
最常见的守护线程:
垃圾回收线程
提问:守护线程和用户线程有什么区别?
Java 线程分为守护线程(Daemon Thread) 和 用户线程(User Thread)两类.
通常情况下,我们使用Thread 创建的线程在默认情况下都属于用户线程, 当在启动线程之前, 执行thread.setDaemon(true)
时, 线程会变成守护线程。
其实在本质上,用户线程和守护线程并没有太大区别,唯一的区别就是会影响虚拟机的退出(程序的终止)。
当jvm中只剩下守护线程时,虚拟机会退出,及程序终止;
而当jvm中至少拥有一个用户线程时,jvm都不会退出。
———————————————
如何设置守护线程 Daemon Thread?
可以通过调用Thread类的setDaemon(true)
方法来设置当前的线程为守护线程;
注意事项:
setDaemon(true)
方法必须在start()
之前调用,否则会抛出IllgalThreadStateException
异常;- 在守护线程中产生的新线程也是守护线程;
- 不是所有的人物都可以分配给守护线程来执行,比如【读写】或【计算】逻辑;
(因为守护线程依附于用户线程而存在,如果守护:读写/计算到一半,用户程序退出,那么读写/计算也会退出,那么程序就崩溃了)
———————————————
模拟一个设计不合理的程序
/*
* 情境:主线程 + 守护线程
* 守护线程:往文件中不断写数据;(模拟一个设计不合理的程序)
* 主线程:阻塞等待来自键盘的输入,一旦获取到了键盘输入,阻塞便解除,
* 当然,主线程一旦结束,守护线程就消失(即使写入数据还未进行完,守护线程也会随着JVM一起结束运行)
*
*/
import java.io.*;
import java.util.Scanner;
class DaemonThread implements Runnable{
@Override
public void run() {
System.out.println("进入守护线程" + Thread.currentThread().getName());
try {
writeToFile();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("退出守护线程" + Thread.currentThread().getName());
}
private void writeToFile() throws Exception {
File filename = new File("/Users/chiu/Desktop"+File.separator+"daemon.txt");
OutputStream os = new FileOutputStream(filename,true);
int count = 0;
while(count < 999){
os.write(("\r\nword" + count).getBytes());
System.out.println("守护线程" + Thread.currentThread().getName()
+ "向文件中写入了word" + count++);
Thread.sleep(1000);
}
}
}
public class Test1 {
public static void main(String[] args) {
System.out.println("进入主线程" + Thread.currentThread().getName());
DaemonThread daemonThread = new DaemonThread();
Thread thd = new Thread(daemonThread);
thd.setDaemon(true); // 设置成守护线程
thd.start();
Scanner sc = new Scanner(System.in);
sc.next(); // 主线程被阻塞;若有输入操作,则解除阻塞,继续执行,从而打印下一句话
System.out.println("退出主线程" + Thread.currentThread().getName());
}
}
/*
* 若守护线程正常退出,那么会输出到999句,且输出:"退出守护线程" + Name
* 若主线程意外退出,守护线程终止,不会输出到999句,且不会输出:"退出守护线程" + Name
*
*/
——————————————
输出:
进入主线程main
进入守护线程Thread-0
守护线程Thread-0向文件中写入了word0
守护线程Thread-0向文件中写入了word1
...
守护线程Thread-0向文件中写入了word30
守护线程Thread-0向文件中写入了word31
aaaaah // 键盘输入了任意字符
退出主线程main
——————————————
桌面的Daemon.txt
word0
word1
word2
...
word29
word30
word31
——————————————————————————————
JStack (生成线程快照)
用JStack
生成线程快照
除了用JStack,还可以用jstat.exe
(命令行工具) jvisualvm.exe
(界面化工具)
JStack:
作用:生成JVM当前时刻线程的快照(threaddump
,即当前进程中所有线程的信息);
目的:帮助定位程序问题出现的原因,如长时间停顿、CPU占用率过高等;(也可以很容易看出哪些是守护线程和用户线程)
总结:
- JStack中,若有
daemon
标识 ,则表示是守护线程;若无,则表示用户线程; - 通过查看
Thread State
线程状态 ,可以让我们了解到导致某个线程死锁、阻塞的原因;(辅以查阅JDK文档)
如java.lang.Thread.State: TIMED_WAITING (sleeping)
, tid
nid
可以让我们直观看到哪些线程CPU占有率过高;
1.在Terminal查看 JStack 信息:
$ jstack
Usage:
jstack [-l] <pid>
(to connect to running process)
// 如果输入【-l】:指显示关于锁的额外信息
jstack -F [-m] [-l] <pid>
(to connect to a hung