多线程之间通讯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 threadLocal=new ThreadLocal(){

protected Integer initialValue(){

return 0;

}

};

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();

}

}