java并发1--多线程基础

一、进程和线程

当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行
1）一个进程之内可以分为一到多个线程
2）线程更轻量，线程上下文切换成本一般上要比进程上下文切换低
3）进程拥有共享的资源，如内存空间等，供其内部的线程共享
4）进程间通信较为复杂
线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量

二、java线程

1、创建和运行线程

1）直接Thread

// 创建线程对象
Thread t = new Thread() {
	public void run() {
		// 要执行的任务
	 }
};
// 启动线程
t.start();

2）线程和任务分离

Runnable runnable = new Runnable() {
	public void run(){
	// 要执行的任务
	}
};
// 创建线程对象
Thread t = new Thread( runnable );
// 启动线程
t.start();

3. FutureTask 配合 Thread

// 创建任务对象
FutureTask<Integer> task3 = new FutureTask<>(() -> {
	log.debug("hello");
	return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);

Fature用保护性暂停模式，获得返回值

2、线程api

obj.wait() 让进入 object 监视器的线程到 waitSet 等待
obj.notify() 在 object 上正在 waitSet 等待的线程中挑一个唤醒（随机）
obj.notifyAll() 让 object 上正在 waitSet 等待的线程全部唤醒
lock。await（）和signal（）
interrupt ：打断wait、sleep、join的线程
LockSupport.park(); //精准控制暂停某个线程，且不依赖Lock和先后顺序
LockSupport.unpark(恢复线程对象)

sleep(long n) 和 wait(long n) 的区别

1. sleep 是 Thread 方法，而 wait 是 Object 的方法
2. sleep 不需要强制和 synchronized 配合使用，但 wait 需要
   和 synchronized 一起用
3. sleep 在睡眠的同时，不会释放对象锁的，但 wait 在等待的时候会释放对象锁
4. 它们状态 TIMED_WAITING （wait不带参数的就是Waiting状态）

wait & notify park & unpark

与 Object 的 wait & notify 相比
1)wait，notify 和 notifyAll 必须配合 Object Monitor 一起使用，而 park，unpark 不必
2)park & unpark 是以线程为单位来【阻塞】和【唤醒】线程，而 notify 只能随机唤醒一个等待线程，notifyAll是唤醒所有等待线程，就不那么【精确】
3)park & unpark 可以先 unpark，而 wait & notify 不能先 notify

3、线程上下文切换

·线程的 cpu 时间片用完
·垃圾回收
·有更高优先级的线程需要运行
·线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

4、线程状态

1、操作系统层面

2、java层面

例如，java在io操作时，其实是阻塞状态，在多线程运行展现出来的还是rennable.

三、函数式接口

1、函数式接口： 只有一个方法的接口

只要是 函数型接口 可以 用 lambda表达式简化（快捷键 alt+enter）
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
在匿名内部类时，加上返回值，future就是callable.

2、四大函数式接口：

1)Function函数式接口 (有入参和出参)

	Function<String,String> function = new Function<String,String>() {
		 @Override
		 public String apply(String str) {
		 	return str;
	 }
	 };
	//简化为以下lamda写法（匿名函数）
	Function<String,String> function = (str)->{return str;};
	

2)Predicate 断定型接口：有一个输入参数，返回值只能是 布尔值！
3)Consumer 消费型接口 ：一个入参没有返回值
4）Supplier 供给型接口 ：没有参数只有返回值
Supplier supplier = ()->{ return 1024; }; // 匿名内部类时，前面部分也都没有了。
System.out.println(supplier.get());

四、共享模型

1、无锁

CAS

2、不可变

# final原理

作用：
属性用 final 修饰保证了该属性是只读的，不能修改
类用 final 修饰保证了该类中的方法不能被覆盖，防止子类无意间破坏不可变性
写：
final 变量的赋值也会通过 putfield 指令来完成，同样在这条指令之后也会加入写屏障，保证在其它线程读到它的值时不会出现为 0 的情况.
读：
复制一份，效率比不带final高。数字小复制在栈中，数字大，赋值在常量池中。
String时保护性拷贝模式。但这样会大量创建对象，使用享元模式处理。

比如大数类，本身通过保护性拷贝，达到了单个原子性，线程安全。但是在取款例子的方法中，获取-计算-设值，这几步还是分开的，不能保证原子性和线程安全。

3、有锁

Monitor 原理
Monitor 被翻译为监视器或管程
每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的Mark Word 中就被设置指向 Monitor 对象的指针

1）刚开始 Monitor 中 Owner 为 null
2）当 Thread-2 执行 synchronized(obj) 就会将 Monitor 的所有者 Owner 置为 Thread-2，Monitor中只能有一个 Owner
3）在 Thread-2 上锁的过程中，如果 Thread-3，Thread-4，Thread-5 也来执行 synchronized(obj)，就会进入EntryList BLOCKED
4）Thread-2 执行完同步代码块的内容，然后唤醒 EntryList 中等待的线程来竞争锁，竞争的时是非公平的
5）图中 WaitSet 中的 Thread-0，Thread-1 是之前获得过锁，现在陷入WAITING状态的