JAVA多线程

synchronized 锁住当前对象的理解

public class TT implements Runnable {
    int b = 100;
    
    public synchronized void m1() throws Exception{
        //Thread.sleep(2000);
        b = 1000;
        Thread.sleep(5000);
        System.out.println("b = " + b);
    }
    
    public  void m2() throws Exception {
        Thread.sleep(2000);
        b = 2000;
    }
    
    public void run() {
        try {
            m1();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws Exception {
        TT tt = new TT();
        Thread t = new Thread(tt);
        t.start();
        tt.m2();
    }
}

m1()方法和m2()方法都访问了成员变量b，m1有加锁(对调用m1方法的对象加锁) m2没有加锁

打印结果:b=2000 tt.m2()方法并没有等t线程执行结束就访问了m1()  t.start()和tt.m2()并没有同步

结论：

类的这个对象，是一个资源
这个资源能不能好好的被访问，就像账户里的钱 能不能保证前后访问一致
你必须把访问这个资源的所有的方法，都要考虑到是否设置成同步的(加锁)

锁住当前对象只是针对加了synchronized 关键字m1()这段方法，另外一个线程绝对不可能执行这段代码，但是有可能执行其他的代码m2()

模拟生产者与消费者

生产者和消费者例子中，蕴含了多线程很多个知识点

启动线程、 synchronized关键字sleep 、 wait 和notify的用法 以及数据结构中的栈

package javaee.net.cn.thread;
public class ProducerConsumer {
    //这里用是三个生产者线程和一个消费者线程来测试
    //如果想要把生产者生产的全部消费完 消费者的run方法执行的次数就需要时生产者的三倍 (i<6)
    public static void main(String[] args) {
        SyncStack ss = new SyncStack();
        Producer p = new Producer(ss);
        Consumer c = new Consumer(ss);
        //启动线程是调用start()方法，如果直接调用run方法就是普通的方法调用，不是异步的。
        new Thread(p).start();
        new Thread(p).start();
        new Thread(p).start();
        new Thread(c).start();
    }
}
//这是声明一个对象 用来放进栈里面
class WoTou {
    int id; 
    WoTou(int id) {
        this.id = id;
    }
    public String toString() {
        return "WoTou : " + id;
    }
}
/**
 * 数据结构中 栈
 * 有push和pop方法 
 */
class SyncStack {
    int index = 0;
    WoTou[] arrWT = new WoTou[6];
    //因为arrWT 和index是成员变量，所以需要对这两个方法加锁。 加锁是锁住当前对象，他里面的成员变量自然也就锁定了
    public synchronized void push(WoTou wt) {
        //须用while 而不是if 因为如果栈满了 需要一直等待
        while(index == arrWT.length) { 
            try {
                //栈满了时 需要停止住
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //wait不同于sleep 不需要指定睡眠的时间， 但需要手动唤醒. 当index不等arrWT.length 表示栈现在不是满的可以进行push 于是手动唤醒线程
        this.notifyAll();    
        //如果不加锁 arrWT和index因为多线程同步 导致新加的窝头和指针不匹配
        //先把当前指针 执行新加的窝头
        arrWT[index] = wt;
        //然后把指针加1
        index ++; 
    }
    //pop操作和push操作刚好相反
    public synchronized WoTou pop() {
        while(index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notifyAll();
        index--;
        return arrWT[index];
    }
}
/**
 * 定义一个生产者 每生产一个对象 睡眠200ms
 */
class Producer implements Runnable {
    SyncStack ss = null;
    Producer(SyncStack ss) {
        this.ss = ss;
    }
    @Override
    public void run() {
        for(int i=0; i<2; i++) {
            WoTou wt = new WoTou(i);
            ss.push(wt);
            System.out.println("生产了：" + wt);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }            
        }
    }
}
/**
 * 定义一个消费者 
 */
class Consumer implements Runnable {
    SyncStack ss = null;
    Consumer(SyncStack ss) {
        this.ss = ss;
    }
    @Override
    public void run() {
        for(int i=0; i<6; i++) {
            WoTou wt = ss.pop();
            System.out.println("消费了: " + wt);
            try {
                //每消费一个对象 睡眠200ms  可以在console控制台 慢慢的看到线程的调度执行
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }            
        }
    }
}

生产了：WoTou : 0
生产了：WoTou : 0
生产了：WoTou : 0
生产了：WoTou : 1
消费了: WoTou : 1
消费了: WoTou : 1
消费了: WoTou : 1
生产了：WoTou : 1
生产了：WoTou : 1
消费了: WoTou : 0
消费了: WoTou : 0
消费了: WoTou : 0

这是三个生产者一个消费者 最后的打印结果，可见 生产的窝头全部都被消费了

补充 volatile关键字和syschronized

synchronized声明不会被继承，如果一个用synchronized修饰的方法被子类覆盖，那么子类中的这个方法不再保持同步，除非也用synchronized修饰(锁重入)

synchonized 最能用来锁定字符串常量(因为常量池里面只有一个对象 如果允许，各种第三方jar包都锁定了同一个对象)，也不能锁定基础的数据类型

补充：程序之中如果出现了异常，锁会被释放，会被其他程序冲进来(程序乱入，导致数据不一致 访问到异常产生中间的数据)

解决办法:Catch住异常

线程的常用方法和关键字

wait()和join()方法都会释放锁(join方法的底层也是使用了wait方法)

wait:的目的是为了多个线程抢资源的时候，当前线程把资源让出来
如果没有锁，就不存在两个线程抢资源的情况，也就没有必要把资源让出来，两个线程早就一起跑了 这也很好解释了为什么wait方法要和synchronized关键字连用。

join():合并某个线程，他调用此方法的线程(别的线程)合并到当前线程上来。等待调用此方法的线程执行完了，当前线程才开始继续执行(经常用于等待另外一个线程的结束，有点像方法调用)。

interrupt():中断阻塞会释放当前锁(如执行System.in.read() 也会进入阻塞状态等待用户的输入、调用了其他线程的join()方法、等待获取某个对象的锁 如死锁、wait())等都会进入阻塞状态。

注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的

sleep()和yield()方法，当前线程都会放弃CPU，并且都不会释放锁

sleep():的过程之中 如果对当前对象加锁了(可以不加)，不会释放当前对象的锁。

yield(): 当前线程会做出让出CPU使用的暗示，但是线程调度器可能会忽略这个暗示

----------------------------------------------------------------------------------------------

notify():当一个线程执行了s.notify()后，如果在对象s上等待有许多个线程，那么java虚拟机随机取出一个线程，把它放到对象s的锁池去竞争获取锁的机会；

如果对象s的锁池中没有任何线程，那么notify()方法什么也不做。

等待池：假如线程A调用了某个对下的wait()方法，线程A就会释放该对象的锁，同时线程A就进入到了该线程的等待池中，进入到等待池中的线程不会竞争到该对象的锁。

锁池：   假如线程A已经拥有了某个对下的锁，而其他线程B，C想要调用这个对下的某个Synchronized方法，

　　      此时B，C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。

JAVA多线程死锁

产生死锁的原因:

不同的线程等待不可能被释放的锁 互相等待对方释放锁

看一个死锁的例子，

/**
 * 当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要额外的同步
 * 或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那么这个对象是线程安全的
 */
public class TestDeadLock implements Runnable {
    public int flag = 1;
    private static Object o1 = new Object();
    private static Object o2 = new Object();
    public void run() {
        System.out.println("flag=" + flag);
        if(flag == 1) {
            synchronized(o1) {
                try {
                    //睡眠500ms，让t2线程执行先锁住o2
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //因为t1线程睡眠了500ms t1执行到这里的时，o2已经被 t2锁住了
                synchronized(o2) {
                    System.out.println("死锁住了1");    
                }
            }
        }
        if(flag == 2) {
            synchronized(o2) {
                synchronized(o1) {
                    System.out.println("死锁住了2");
                }
            }
        }
    }    
    
    public static void main(String[] args) {
        TestDeadLock td1 = new TestDeadLock();
        TestDeadLock td2 = new TestDeadLock();
        td1.flag = 1;
        td2.flag = 2;
        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.start();
        t2.start();        
    }
}

上面代码执行的流程是，线程t1和线程t2异步执行。 执行线程t1的时 先锁住o1 此时线程t1 睡眠500ms。t2线程开始执行，t2线程锁住o2

等t2线程执行的时候 需要拿到o1的锁才能执行下去，此时1线程往下执行的时候 需要拿到o2的锁才能继续执行

t1线程和t2线程互相持有对方锁(t1锁住了o1 拿到o2的锁就可以继续执行了，t2锁住了o2，拿到o1的锁就可以继续执行了) 陷入了死锁的状态。

死锁解决办法
死锁是程序设计的Bug 在设计程序时就要避免双方互相持有对方锁的情况，只要互相等待对方释放锁就有可能出现死锁

当几个线程都需要访问共享资源A B和C时，保证每个线程都以相同的顺序执行他们，比如都先访问A，在访问B和C。

concurrent并发包

Lock

ReentrantLocak和sysnchronized的区别

支持异步的Callable接口和Future接口

1）Callable接口：它和Runnable接口有点类似，都指定了线程所需要执行的操作。区别在于，Callable接口是在call()方法中指定线程所要执行的操作的，并且该方法有泛型的返回值<V>。

此外 Callable实例不能像Runnable实例那样，直接作为Thread类的构造方法的参数。

2）Future接口：能够保存异步运算的结果。

get()：方法返回异步运算的结果。如果运算结果还没处理，当前线程就会被阻塞，直到获得运算结果，才结束阻塞。

下面程序演示两个线程之间异步运算的过程。

public class Machine implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for(int a=0;a<100;a++){//计算从1加到100
            sum=sum+a;
            Thread.sleep(20);
        }
        return sum;
    }

    public static void main(String[] args) throws Exception {
        FutureTask<Integer> task=new FutureTask<Integer>(new Machine());
        Thread threadMachine = new Thread(task);
        threadMachine.start();// 执行Machine的call()方法
        System.out.println("等待计算结果...");
        //主线程调用task.get()方法 获得运算结果
        System.out.println("从1加到100的和："+task.get());
        System.out.println("计算完毕");
    }
    
}

在以上程序中，Machine类实现了Callable接口，threadMachine线程负责执行Machine类的call()方法，该方法会计算从1加到100的和，并且返回运算的结果。

主线程调用task.get()方法，当ThreadMachine线程还没运算完毕时，主线程就会阻塞，直到threadMachine线程执行完call()方法，主线程才会获得运算结果，并从task.get()方法中退出。