Java学习笔记-全栈-Java基础-10-多线程

1. 程序、进程、线程

概念

• 程序：静态的概念（资源分配的单位）
• 进程：运行的程序（调度执行的单位）
• 线程：一个程序中有多个事件同时执行，每个事件一个线程，多个线程共享代码和数据空间

2. 创建线程的方法

• 1.继承thread类（由于类只能单继承，少用）
• 2.实现runnable接口（主要使用）
• 3.实现callable接口（juc下的）

每个线程都有优先级，但优先级只代表优先的概率更大

• 用户线程：必须等用户执行完才能停下，最高优先级
• 守护线程：jvm停止之前，一定会等用户线程，但不等守护线程，最低优先级（只用于服务用户线程）
• 默认状况下，所有线程都是用户线程

3. 通过lambda实现多线程

3.1 什么是lambda

对于一次性的方法：
外部类-》静态内部类-》局部内部类-》匿名内部类-》lambda

import java.lang.Thread;

interface iLike{
	void lambda();
}

public class Test2 {

//静态内部类
//	static class Like2 implements iLike{
//		public void lambda() {
//			System.out.println("Like2");
//		}
//	}

	public static void main(String[] args) {
		iLike like = null;
//		iLike like = new Like();  //外部类
//		like.lambda();

//		like = new Like2(); //静态内部类
//		like.lambda();

//		class Like3 implements iLike{ //方法内部类
//			public void lambda() {
//				System.out.println("Like3");
//			}
//		}
//		like = new Like3();
//		like.lambda();

//		like = new iLike() {  //匿名内部类
//			public void lambda() {
//				System.out.println("Like4");
//			}
//		};
//		like.lambda();

//Lambda,是对接口的实现
		like = ()->{
			System.err.println("labmda Like");
		};
		like.lambda();
	}
}

//外部类
//class Like implements iLike{
//
//	public void lambda() {
//		System.out.println("Like1");
//
//	}
//
//}

lambda是对接口方法的实现，且该接口仅允许有一个方法。

() -> {}():

• ()：接口方法的括号，接口方法如果有参数，也需要写参数。若只有一个参数时，括号可以省略。
• -> : 分割左右部分。
• {} : 要实现的方法体。只有一行代码时，可以不加括号，可以不写return。

new Thread(()->System.out.println(“多线程中的lambda”)).start().

4. 线程状态

进入就绪状态的情况：

• 1.Start()
• 2.阻塞解除
• 3.运行时调用yield，（若没有其他线程在排队，则yield无效）
• 4.Jvm线程切换

进入阻塞状态的情况

• 1.Sleep：占用资源等待（不会释放锁），通常用于模拟延时，放大错误发生的可能性（检查线程不安全情况）
• 2.Wait：不占资源等待（会释放锁）
• 3.Jion：合并线程，当此线程执行完毕后，再执行其他线程（在A里面调用B.join()，B插队了，A被阻塞了，等B执行完了A再走）
• 4.IO流阻塞，Read、write：必须由操作系统去调度，因此也会阻塞

线程死亡（一般不要使用自带的stop、destroy摧毁）

• 1.在thread中加一个Boolean flag变量，当其为true的时候执行run。thread对外提供一个停止方法，更改flag的值为false，实现停止。

注意

• 1.setDaemon只能在线程启动之前对其使用
• 2.进入新生状态之后，便拥有自己的工作空间，与主存进行交互
• 3.setPriority 范围1-10，默认5
• 4.解除阻塞都是进入就绪状态，而非进入运行状态！
• 5.解除阻塞都是进入就绪状态，而非进入运行状态！
• 6.解除阻塞都是进入就绪状态，而非进入运行状态！

4.1 Thread.State

State state = t.getState(); (t为写好的线程实例)

• NEW：尚未启动
• RUNNABLE：在JVM中执行（包含就绪状态和运行状态）
• BLOCKED：被阻塞
• WAITING：正在等待另一个线程执行特定动作
• TIMED_WAITING：正在等待另一个线程达到指定运行时间
• TERMINATED：已退出

5. 线程同步

同步锁 synchronized：

锁的是可能被多个人修改的“资源”，而非方法

• 1.调用成员方法锁this，调用静态对象锁class
• 2.对于容器锁定，有对应的并发容器类供使用

死锁：相互等待对方的资源，一般发生在锁套锁的情况。

6. 线程通信（线程同步、并发协作）

Java提供了以下方法：注意只能在同步方法或同步块中使用

方法名	作用
final void wait()	表示线程一直等待，直到其他线程通知；与sleep不同，wait会释放锁
final void wait(long timeout)	指定等待毫秒数
final void notify()	唤醒一个处于等待状态的线程
final void notifyAll()	幻想同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

7. 生产者与消费者模式

1.一个生产者消费者模型，共有4个类：生产者，消费者，容器，数据。3+N个实例：生产者，消费者，容器，N个数据。
2.生产者和消费者通过容器实现通信，即，双方共用一个容器（双方传入相同的容器）
3.容器实现生产和消费的方法（实际就是容器本身的增删方法）
4.生产者和消费者为多线程，调用容器的增删。容器中的增删方法为同步方法。

7.1 管程法

public class Consumer2Producter {
	public static void main(String[] args) {
		Container container = new Container();
		Comsumer comsumer = new Comsumer(container);
		Product product = new Product(container);
		comsumer.start();
		product.start();
	}
}

//生产者
class Product extends Thread{
	Container container;
	public Product(Container container) {
		this.container = container;
	}
	public void run() {
		for (int i = 1; i <= 10; i++) {
			Steamebun bun = new Steamebun(i);
			//push是同步方法，存在等待的过程，为保证输出正确，这句话要在push之前
			System.out.println("生产了馒头"+bun.id+"号"); 
			container.push(bun);
		}
	}
}
//消费者
class Comsumer extends Thread{
	Container container;
	Comsumer(Container container){
		this.container = container;
	}
	public void run() {
		for (int i = 1; i <= 10; i++) {
			System.out.println("消费了馒头："+container.pop().id+"号");
		}
	}
}
//数据
class Steamebun{
	int id;
	Steamebun(int id){
		this.id = id;
	}
}
//缓冲区（容器）
class Container{
	Steamebun[] steamebuns = new Steamebun[10];
	int count;
	//生产
	public synchronized void push(Steamebun steamebun){
		if (steamebuns.length==count) {
			try {
				this.wait();
			} catch (InterruptedException e) {
			}
		}
		steamebuns[count++] = steamebun;
		this.notify();
	}
	//消费
	public synchronized Steamebun pop() {
		if (count==0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
			}
		}
		Steamebun bun = steamebuns[--count];  //先减再用
		this.notify();
		return bun;
	}
}

7.2 信号灯法

跟管程法差不多，区别就在于在容器中利用flag真假来控制线程切换。（没有具体容器上限的时候需要使用信号灯法，因为管程法是利用是否达到容器上限来控制线程切换的）

8. 其他相关

8.1 定时任务

类实现：

• Java.util.Timer 类似闹钟，本身就是一个线程
• Java.tuil.TimerTask 抽象类，实现了runnable，具备多线程能力

任务调度框架：

• QUARTZ(已经集成到Swing中)
• Scheduler-调度器
• Trigger-触发条件，采用DSL模式
• JobDetail-需要处理的JOB
• Job-执行逻辑
• DSL：领域专用语言，声明式编程（简介、连贯的代码解决问题）
  • 1.Method Chaining方法链，builder模式构建器
  • 2.Nested Functions嵌套函数
  • 3.Lambda表达式
  • 4.Functional Sequence

8.2 HappenBefore

当多行代码没有依赖的时候，为了减少“内存操作速度慢而CPU速度快导致CPU等待内存而影响效率“的情况，jvm和CPU会尝试重排指令顺序，加快运行速度。这就导致代码不一定按你写的顺序执行。

语句的执行的最后一步，从CPU中将 计算好的值传回内存，在这个过程中，由于CPU速度快，内存速度慢，可能发生计算好的值还没传回内存，新的指令就使用了该值的旧值。

简单理解：语句A和语句B按AB排列，若A执行完毕会非常慢，而jvm判断B又与A没有依赖，那么为了保证CPU不闲置，jvm会提前执行B。

最常见的例子：

• 多线程下，每个线程都有自己的工作空间，当线程A从主内存中拿到数据x之后，对其进行更改；当更改x过程还没结束的时候，线程B就拿走了x，此时就出现了使用旧值的情况。
  但是，表面看似B对A没有依赖，但可能因为多线程的关系，在其他线程中AB存在依赖，这就导致不合理的结果。

public class HappenBefore {
	static int a;
	static boolean flag;
	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 10; i++) {
			a=0;
			flag=false;
			Thread t1 = new Thread(()-> {
				a=1;
				flag=true;
			});
			Thread t2 = new Thread(()-> {
				if (flag) {
					a*=1;
				}
				if (a==0) {
					System.out.println("HappenBefore a-->"+a);
				}
			});
			t1.start();
			t2.start();
		}
	}
}

上面的代码，理想情况下，只会输出a–>0，但实际还会输出a–>1；

8.3 Volatile

为了避免多线程中的数据的HappenBefore，volatile保证了多线程之间变量的可见性。（轻量级的synchronize）

8.4 CAS操作

保证原子性，使用CAS原子操作
对于数据A，在时间轴上有三个值：内存中的A1，”看到的“A，要更新的目标值A2
CAS操作时，将A1与A进行比较，若不相同，则不进行操作，返回flase
若相同，则修改为A2，返回true。

8.5 本地线程（重要）

ThreadLocal【本地线程】

在多线程的程序中，我们一般会申请共享变量，给所有线程使用。
但是很多情况下，每个线程会对共享变量进行改变。
比如，一个String 类型的static变量，线程一将String 赋值为 “线程一”，然后在跑其他的逻辑的时候，第二个线程将String 又改成了“线程二”，那么就会出个问题，线程一跑到后面在对该String进行使用的时候，就发现值已经被改变了。
此时就需要ThreadLocal，相当于，每个线程拥有了独立的数据空间。

优点：
1.通过当前线程的前进，传递对象（而不需要通过一路传参到处传递）（创建线程的局部变量）
2.每个线程使用各自的数据空间，保证线程之间的变量处理互不影响

ThreadLocal的源码非常简单，就是通过一个HashMap存放数据。

public class ThreadLocal{
	private Map<Runnable,Object> container = new HashMap<Runnable,Object>();
	
	public void set(Object value){
		container.put(Thread.currentThread(),value);//用当前线程作为key
	}
	
	public Object get(){
		return container.get(Thread.currentThread());
	}
	
	public void remove(){
		container.remove(Thread.currentThread());
	}
}