异步应用
视频格式转换
新建线程
方法一
Thread t = new Thread(){
public void run(){
// 要执行的任务
}
};
// 可以给线程取名字
t.setName("线程1");
// 这里才是交给任务调度器调度,交给cpu执行
t.start();
方法二
Runnable runnable = new Runnable(){
public void run(){
// 要执行的任务
}
};
// 可以给线程取名字
Thread t = new Thread(runnable,"线程2");
// 这里才是交给任务调度器调度,交给cpu执行
t.start();
****************Java8简化***************************************
Runnable runnable = ()->{
// 要执行的任务
logger.info("666");
};
// 可以给线程取名字
Thread t = new Thread(runnable,"线程2");
// 这里才是交给任务调度器调度,交给cpu执行
t.start();
原理分析:两个走的都是Thread的run方法,但是用Thread新建的对象会重写这个run方法
方法三
// 这里泛型可以自定义返回值的类型
FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
// 要执行的任务
return 100;
}
});
// 可以给线程取名字
Thread t = new Thread(futureTask,"线程3");
// 这里才是交给任务调度器调度,交给cpu执行
t.start();
// 会阻塞 一直等待到结果返回
futureTask.get();
start方法只是让线程进入就绪状态,能不能运行由任务调度器说了算,而且只能调用1次。
run方法直接调用的话也可以,不过是main线程调用的,就失去多线程的意义了,不能提高性能。
Linux常用命令
jsp:java的命令 查看当前跑的java进程id
top:查看cpu 内存占用等资源信息
top -h(-h表示我要查看线程) -p (-p表示看哪个指定的进程id) 4563
线程运行原理
栈:栈内存是给谁用的?其实就是线程,每个线程启动后,虚拟机就会为其分配一块栈内存。
栈帧:每个栈由多个栈帧组成,每个线程调用方法的时候就会产生栈帧的一块内存,每个线程只能有一个活动栈帧,也就是对应当前执行的那个方法。
每一个都是栈帧
方法执行完就释放了
局部变量表:对应局部变量和方法参数
这些局部变量表在创建栈帧时就已经分配好了
返回地址:记录方法执行完回到原来的位置
不同的线程有自己独立的栈帧,他们之间互不干扰。
线程的上下文切换
线程从使用cpu到不使用cpu
1.现成的cpu时间片使用完了
2.垃圾回收
3.有更高优先级的线程需要运行
(主动)4.线程自己调用sleep、yield、wait、join、park、synchronized、lock等方法
当发生上下文切换时,需要由操作系统保存线程的当前状态(程序计数器),频繁上下文切换会影响性能。
Sleep
1.调用sleep会让线程从RUNNING状态到TIME_WAITING状态(阻塞状态)
2.中途调用线程的interrupt方法可以唤醒该线程,但是会抛出interruptedException异常。
3.睡眠结束后的线程不一定会马上执行
4.可读性更好的睡眠方法:TimeUnit.SECONDS.sleep(1);
yield
1.调用该方法会让线程从RUNNING状态到RUNNABLE状态,然后调度其他线程,具体还是会交给任务调度器,有可能下一次又会分给自己。
总的来说yield和优先级(优先级大的优先执行)并不能真正有效进行控制,只是会产生影响
while(true){
// 死循环里加上sleep,不需要sleep太久,避免空转浪费cpu资源,防止cpu占用100%
Thread.sleep(50);
}
Join
1.等待调用join的线程执行完才会往下继续执行
join(long n)有时效的等待,最大等待n毫秒,join不会按这个最大时间去等,可以提前结束。
interrupt
1.可以打断处于阻塞状态的线程比如:sleep、wait、join
2.打断以后会抛出异常,因为sleep、wait、join被打断后就会以异常的方式表示被打断而不是打断标记,打断标记会重置为false。
3.如果是正常运行的过程中被interrupt打断的话,程序并不会终止运行,需要用打断标记isInterrupt来进行判断是否要结束程序。
两阶段终止模式
在线程T1中如何【优雅】的终止线程T2?这里要给T2一个料理后事的机会。
错误思路
1.使用stop()方法杀死线程,如果这是线程🔐锁住了共享资源,name它被杀死以后就没有机会释放锁,其他线程也就无法再获取锁了。
2.使用System.exit(int)方法停止线程,这会导致整个程序都停止,而不是当前线程停止。
以监控系统监控为例
如果代码是非正常打断会抛异常,此时重新再将打断标记设置为true即可。
演示:
interrupted()和isInterrupted()区别
interrupted()会打断标记,调用完返回true或false后会清除打断标记;
isInterrupted()不会打断标记,调用完后返回true或false。
park()
1.调用park()方法后,线程会进入阻塞状态,不会继续执行下面的代码,可以用Interrupt()方法进行唤醒,并且唤醒后打断标记会置为true。
2.park()方法只能打断一次,如果后面唤醒了再用park(),也无法再次打断,除非把打断标记重新置为false,name此时park()又可以被再次打断。
过时(不推荐的方法)
会破坏同步代码块,容易对象锁得不到释放,容易造成死锁
1.stop()
2.suspend()——让线程暂停
3.resume()——让线程恢复
守护线程
1.一般情况下只要有一个线程还在运行,java进程就不会结束。
2.只要其他非守护线程结束了,即使守护线程还没执行完也会强制结束。
3.设置为守护线程:该线程调用Daemon(true)并设置为true,默认是非守护线程。
4.垃圾回收器就是一种守护线程。
5.Tomcat中Acceptor和Poller都是接收和分发请求的线程,当Tomacat接收到shutdown命令后不会等待他们处理完请求就把线程给结束了。
线程的状态-5种
从操作系统的层面上来说的
初始状态:只是在语言的层面上创建了线程对象,还没有和操作系统关联。
可运行状态(就绪状态):指可以被操作系统的任务调度器来进行调度,时刻准备着可以被cpu分到时间片去运行。
运行状态:获得cpu时间片,并且正在执行代码的进程。
阻塞状态:某一个线程调用了阻塞的api。
终止状态:线程执行完毕,生命周期已经结束且不会切换到其他状态
线程的状态-6种
从java-API的层面上来说的,从Thread的State枚举来说的
java-API层面的RUNNABLE状态涵盖了操作系统层面的【可运行状态】【运行状态】【阻塞状态】,(java里区分不出运行状态和可运行状态和阻塞状态)
NEW:新建线程但不start
TERMINATED:终止状态
TIMED_WAITING:
就是sleep,有时间的睡
WAITING:
调用join()
这里等待t2执行完才轮到t5,但t2是死循环,永远不会结束,所以一直是WAITING(没有时限)
BLOCKED:
锁🔐在t4手里,t6拿不到锁所以被BLOCKED了
线程安全问题
java中对静态变量的自增和自减并不是原子操作
如果是单线程,只要按顺序执行写入主存就不会有问题
如果是不同的线程指令交错写回就会发生问题
根本原因:上下文切换
临界区
一段代码块如果存在对共享资源的多线程读写操作,称这段代码块为临界区。
竞态条件
多个线程在临界区内执行,由于代码的执行序列不同,导致结果无法预测,则称之为发生了竞态条件。
Synchronized解决方案
为了避免临界区的竞态条件发生,有两种解决方案
阻塞式的解决方案:Synchronized,Lock
非阻塞式的解决方案:原子变量
Synchronized采用的是【对象锁】,它采用的是互斥的方式让同一时刻最多只有一个线程能持有【对象锁】,其他线程想获取这个【对象锁】就会被阻塞,这样就能保证拥有【对象锁】的线程可以安全的执行临界区的代码,不用担心线程的上下文切换。
synchronized(对象){
//临界区
}
第3步的t2会发生上下文切换,从运行状态切换到阻塞状态。
第5步当自己Synchronized的代码执行完以后,会唤醒除自身外其他的所有线程。
注意:
1.Synchronized其实是用【对象锁】来保证临界区代码的原子性(不可分割,不会被线程切换所打断)
2.要保护共享资源,就得保证多个线程是给同一个对象加锁🔐
3.如果一个加锁,一个不加锁,同样没作用,因为不加锁的线程不会去获取锁就能直接操作共享的资源了。
面向对象写法改进:
获取值也需要加锁🔐,这样可以防止获取到的变量是中间值
方法上的Synchronized
public synchronized void test(){
}
// 等价于
public void test(){
synchronized(this){
//临界区
}
}
//-------------------------------------------------------------
public synchronized static void test(){
}
// 等价于
public static void test(){
synchronized(当前类.class){
//临界区
}
}
线程“八锁🔐”
1.会互斥 12/21
- 会互斥 1秒后打印1 然后打2/先打2 一秒后打1
3.c方法不会互斥 先打3 1秒后打1再打2 , 先打3再打2 1秒后打1,先打2再打3 1秒后打1
4.不互斥 先打2 1秒后打1
5.不互斥 因为锁住的不是同一个对象 先打2 1秒后输出1
6.互斥, 先打2 1秒后打1 or 1秒后打1 再打2
7.不互斥 🔐的不是同一个对象,先打2 一秒后打1
8.互斥 因为n1和n2 用的是同一个类对象 类对象只有1个 所以 先打2 1秒后打1 or 1秒后打1 再打2
变量线程安全分析
局部变量线程安全分析
不同线程操作的i不一样,互不干扰。
如果操作同一个成员变量就会出错
如果下面代码分别使用public和private是否会出现线程安全问题?
答:不会。
如果是private,别的线程无法调用method2和method3,只有method1能调用不会产生线程安全问题。
如果是public,别的线程传进来的list不可能和method1里传的是同一个对象,所以也不会产生线程安全问题。
如果改进一下,写一个这个类的子类,重写method2或method3方法是否会发生线程安全问题?
答案是有线程安全问题,因为内部新起了一个新的线程,这个线程的list和原来method1线程里的是同一个对象。
原因:局部变量的引用暴漏给了其他线程。
如果把访问修饰符修改成private,那么子类重写的method3和父类就不是同一个method3