JUC的一些基本功能

异步应用

视频格式转换

新建线程

方法一

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秒后打印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