多线程之间通讯JDK1.5-Lock

synchronized：代码开始上锁，代码结束时释放锁；内置锁、自动化的、效率低、扩展性不高（不够灵活）；

JDK1.5并发包Lock锁 --保证线程安全问题，属于手动挡，手动开始上锁，手动释放锁，灵活性高；

Lock 接口与 synchronized 关键字的区别
Lock 接口可以尝试非阻塞地获取锁 当前线程尝试获取锁。如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁。
Lock 接口能被中断地获取锁 与 synchronized 不同，获取到锁的线程能够响应中断，当获取到的锁的线程被中断时，中断异常将会被抛出，同时锁会被释放。

Lock 接口在指定的截止时间之前获取锁，如果截止时间到了依旧无法获取锁，则返回。

Lock用法：

Lock写法
Lock lock = new ReentrantLock();
lock.lock();
try{
//可能会出现线程安全的操作
}finally{
//一定在finally中释放锁
//也不能把获取锁在try中进行，因为有可能在获取锁的时候抛出异常
lock.ublock();
}
class Res{
public String username;
public String sex;
//true 生产者等待，消费者可消费 false生产者可以生产，消费者不可消费
public boolean flag=false;
Lock lock=new ReentrantLock();
}
class Out extends Thread{
Res res;
Condition newCondition;

public Out(Res res,Condition newCondition){
    this.res=res;
    this.newCondition=newCondition;
}
@Override
public void run() {
    //写操作
    int count=0;
    while (true){
        try{//防止异常后不释放锁
            res.lock.lock();
            if(res.flag){
               newCondition.await();//让当前线程从运行变为阻塞，并且释放所的资源
            }
            if(count==0){//偶数
                res.username="小明";
                res.sex="男";
            } else {//奇数
                res.username="小红";
                res.sex="女";
            }
            count=(count+1)%2;
            res.flag=true;
            newCondition.signal();
        } catch (Exception e){
        } finally {
            res.lock.unlock();
        }
    }
}

}
class Input extends Thread{
Res res;
Condition newCondition;
public Input(Res res,Condition newCondition){
this.res=res;
this.newCondition=newCondition;
}

@Override
public void run() {
    while (true){
        try{
            res.lock.lock();
            if(!res.flag){
                newCondition.await();//让当前线程从运行变为阻塞，并且释放所的资源
            }
            System.out.println(res.username+","+res.sex);
            res.flag=false;
            newCondition.signal();
        } catch (Exception e){
        } finally {
            res.lock.unlock();
        }
    }
}

}
public class LockDemo {
public static void main(String[] args) {
Res res = new Res();
Condition condition=res.lock.newCondition();
Out out = new Out(res,condition);
Input input = new Input(res,condition);
out.start();
input.start();
}

}

Condition用法：

Condition condition = lock.newCondition();
res. condition.await(); 类似wait
res. Condition. Signal() 类似notify
多线程并发（Thread）操作同一个资源---------网站并发（多个请求同时访问一台服务）

停止线程

停止线程思路

1. 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

2.  使用stop方法强行终止线程；这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果（没执行完就终止没有记录上次执行点，并且不可恢复，不论你当前什么状况都给你停掉）。



3.  使用interrupt方法中断线程。

那么怎么停止线程比较合适呢？或者说怎么设计一种停止线程的方式？

class StopThreadDemo extends Thread{
private volatile boolean flag=true;

@Override
public void run() {
    System.out.println("子线程开始执行......");
    while (flag){

    }
    System.out.println("子线程执行结束......");
}
public void stopThread(){
    this.flag=false;
}

}
public class StopThread {
public static void main(String[] args) throws InterruptedException {
StopThreadDemo stopThreadDemo=new StopThreadDemo();
stopThreadDemo.start();
for (int i = 0; i < 10; i++) {
System.out.println("我是主线程，i:"+i);
Thread.sleep(1000);
if(i==6)
stopThreadDemo.stopThread();
}
}
}

我是主线程，i:0
子线程开始执行......
我是主线程，i:1
我是主线程，i:2
我是主线程，i:3
我是主线程，i:4
我是主线程，i:5
我是主线程，i:6
我是主线程，i:7
子线程执行结束......
我是主线程，i:8
我是主线程，i:9

class StopThreadDemo extends Thread{
private volatile boolean flag=true;

@Override
public synchronized void run() {
    System.out.println("子线程开始执行......");
    while (flag){
        try {
            wait();
        } catch (InterruptedException e) {

// e.printStackTrace();
stopThread();
}
}
System.out.println("子线程执行结束......");
}
public void stopThread(){
this.flag=false;
}
}
public class StopThread {
public static void main(String[] args) throws InterruptedException {
StopThreadDemo stopThreadDemo=new StopThreadDemo();
stopThreadDemo.start();
for (int i = 0; i < 10; i++) {
System.out.println("我是主线程，i:"+i);
Thread.sleep(1000);
if(i==6) {
//当前等待线程直接抛出异常
stopThreadDemo.interrupt();
// stopThreadDemo.stopThread();
}
}
}
}
以上两种方式都可以。。。
可以看到这是一种停止线程的方式

ThreadLocal
ThreadLocal提高一个线程的局部变量，访问某个线程拥有自己局部变量。

线程1和线程2各自操作自己的副本count，互相影响。

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

ThreadLocal的接口方法

ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：

void set(Object value)设置当前线程的线程局部变量的值。
public Object get()该方法返回当前线程所对应的线程局部变量。
public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
protected Object initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。
案例:创建三个线程，每个线程生成自己独立序列号。

class ResNum{
public int count=0;
public static ThreadLocal

public String getNumber(){
    count=threadLocal.get()+1;
    threadLocal.set(count);

// count=count+1;
return count+"";
}
}
class LocalThreadDemo extends Thread{
private ResNum resNum;
public LocalThreadDemo(ResNum resNum){
this.resNum=resNum;
}

@Override
public void run() {
    for (int i = 0; i < 3; i++) {
        System.out.println(getName()+","+resNum.getNumber());
    }
}

}
public class ThreadLocalDemo {
public static void main(String[] args) {
ResNum resNum1=new ResNum();
// ResNum resNum2=new ResNum();
// ResNum resNum3=new ResNum();
LocalThreadDemo t1=new LocalThreadDemo(resNum1);
LocalThreadDemo t2=new LocalThreadDemo(resNum1);
LocalThreadDemo t3=new LocalThreadDemo(resNum1);
t1.start();
t2.start();
t3.start();
}
}