(笔记八)线程、同步代码块、同步函数、死锁

1.线程
是"进程"中某个单一顺序的控制流。也被称为轻量进程（lightweight processes）。计算机科学术语，指运行中的程序的调度单位。

一个进程必须至少有一个线程,通常称为主线程。

2.线程调度
计算机通常只有一个CPU,在任意时刻只能执行一条机器指令,每个线程只有获得CPU的使用权才能执行指令.所谓多线程的并发运行,其实是指从宏观上看,各个线程轮流获得CPU的使用权,分别执行各自的任务.在运行池中,会有多个处于就绪状态的线程在等待CPU

JAVA虚拟机的一项任务就是负责线程的调度,线程调度是指按照特定机制为多个线程分配CPU的使用权.

Windows的调度是以线程为粒度调度的。调度的决策被严格限制在以线程为基础，并不考虑这个线程属于哪一个进程。当考虑到进程并不运行，而仅为其线程提供资源和运行的上下文环境时，这种方法就有意义了，例如，进程A有10个可运行的线程，进程B有2个可运行的线程，而且这12个线程的优先级别相同，那么，每一个线程将会使用1/12的CPU时间，而不是将CPU 50%的时间分配给进程A，50% 的时间分配给进程B。

有两种调度模型：分时调度模型和抢占式调度模型。
分时调度模型是指让所有的线程轮流获得cpu的使用权,并且平均分配每个线程占用的CPU的时间片这个也比较好理解。

java虚拟机采用抢占式调度模型，是指优先让可运行池中优先级高的线程占用CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用CPU。处于运行状态的线程会一直运行，直至它不得不放弃CPU。

一个线程会因为以下原因而放弃CPU：
1 java虚拟机让当前线程暂时放弃CPU，转到就绪状态，使其它线程获得运行机会。
2 当前线程因为某些原因而进入阻塞状态
3 线程结束运行

需要注意的是，线程的调度不是跨平台的，它 不仅仅取决于java虚拟机，还依赖于操作系统。在某些操作系统中，只要运行中的线程没有遇到阻塞，就不会放弃CPU；在某些操作系统中，即使线程没有遇到阻塞，也会运行一段时间后放弃CPU，给其它线程运行的机会。
java的线程调度是不分时的，同时启动多个线程后，不能保证各个线程轮流获得均等的CPU时间片。

如果希望明确地让一个线程给另外一个线程运行的机会，可以采取以下办法之一。
调整各个线程的优先级
让处于运行状态的线程调用Thread.sleep()方法
让处于运行状态的线程调用Thread.yield()方法
让处于运行状态的线程调用另一个线程的join()方法

3.例子

public class Demo {public static void main(String[] args) {new Test();new Test();new Test();new Test();System.gc();//调用gcSystem.out.println("hello world");}}class Test{public void finalize(){System.out.println("test clear");}}

/**
反复运行并观察输出,其结果是不确定的。因为main主线程、垃圾回收线程，它们线程优先级相同，随机占用cpu
*/

4.创建线程方式一
1)定义类继承Thread类，覆盖run方法(线程所要执行的代码)，将业务代码写在run方法中。

2)通过实例化，来创建线程，通过start启动线程，调用线程任务run方法

3)run和start区别
run()方法:在本线程内调用该Runnable对象的run()方法，可以重复多次调用；
start()方法:启动一个线程，调用该Runnable对象的run()方法，不能多次启动一个线程；

4)getName()与Thread.currentThread().getName()
每个继承Thread类的子类，在创建时都有自己的线程名称，都有getName()方法;
run函数中，getName()和Thread.currentThread().getName()是有区别的，前者是线程对象的名称，后者是当前运行线程的名称

5)例子
example01

public class Demo2 {public static void main(String[] args) {Test2 t1=new Test2();Test2 t2=new Test2();//t1.run();//t2.run();t1.start();t2.start();System.out.println(Thread.currentThread().getName());}}class Test2 extends Thread{public void run(){for(int i=1;i<=10;i++){System.out.println(Thread.currentThread().getName());//System.out.println(getName());//run或start结果一样，对象名}}}

example02

public class Demo1 {public static void main(String[] args) {Ticket t1=new Ticket();Ticket t2=new Ticket();Ticket t3=new Ticket();Ticket t4=new Ticket();t1.start();t2.start();t3.start();t4.start();}}class Ticket extends Thread{private static int num=10;public void run(){while(num>0){System.out.println(getName()+":"+--num);}}}

/**
 输出结果可能不是有序的，原因多个线程同时执行，某个线程可能--num后，将值传给println方法，
 执行println方法时，还没有来得及打印，但失去执行权，后来某个时刻又获取到执行权
 */
6)每条线程有自己的栈空间，意味着每个线程都有自己的局部变量

5.线程的五种状态

创建、运行、消亡(run方法结束或stop())、睡眠(sleep)、等待(wait方法，对应notify唤醒方法)

1)cpu的执行资格：可以被cpu处理的线程，在处理队列中
2)cpu的执行权：正在被cpu处理
3)睡眠和等待，设置线程执行资格与执行权
4)运行：既具备执行资格、又有执行权
5)cpu处理某线程时，该线程具备执行资格，执行权，其它线程不具备执行权，但具备执行资格，处于临时阻塞状态，等待执行权
6)睡眠和等待，都不具备

6.创建线程方式二
1)定义类实现Runnable接口，覆盖run方法，将线程的任务代码封装到run中
2)通过Thread创建线程对象，并将Runnable子类对象作为构造函数的参数传递

7.两种创建对比
继承Thread与实现Runnable接口，前者具备线程所有功能，强调is-a的关系，后者仅仅提供线程任务功能，强调has-a
Runnable好处：避免单继承的局限性，将任务从线程中的子类中分离，将任务封装成对象。

8.多线程安全问题
多个线程操作(修改)共享的数据，可能存在安全问题。

9.同步代码块
synchronized(对象)
{

}
好处：解决线程的安全问题
弊端：都会判断同步锁，降低效率
使用前提：多个线程使用同一个锁

===============================分割线==========================

1.同步函数

class Bank implements Runnable {private int sum;private Object obj = new Object();public void add(int num) {synchronized (obj) {sum += num;System.out.println("sum=" + sum);}}public void run() {for (int i = 0; i <= 3; i++) {add(100);}}}

/*add函数中存在同步代码块,可直接改写为同步函数,Object对象可以删除*/

public synchronized void add(int num) {sum += num;System.out.println("sum=" + sum);}

2.同步函数设置在run函数上，会被某个线程一直占用，直到它执行结束，其他线程才能得到处理权

3.同步代码块和同步函数区别
同步代码块的锁是任意的对象，同步函数的锁是this

4.静态同步函数的锁
使用的锁是该方法所在类的字节码文件对象，类名.class或this.getClass()
(字节码文件对象：JVM在加载某个.class文件之后得到的一段字节？？还是就是.class本身？)

5.死锁
是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

简单演示

package lock;public class Demo {public static void main(String[] args) {LockDemo d1=new LockDemo(true);LockDemo d2=new LockDemo(false);Thread t1=new Thread(d1);Thread t2=new Thread(d2);t1.start();t2.start();}}class LockDemo implements Runnable{private boolean flag;LockDemo(boolean flag){this.flag=flag;}public void run(){if(flag){synchronized(Lock.lockA){System.out.println("true lockA");synchronized(Lock.lockB){System.out.println("true lockB");}}System.out.println("true over");}else{synchronized(Lock.lockB){System.out.println("false lockB");synchronized(Lock.lockA){System.out.println("false lockA");}}System.out.println("false over");}}}class Lock{public static final Object lockA=new Object();public static final Object lockB=new Object();}