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;}@Overridepublic 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;}@Overridepublic 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;@Overridepublic 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;@Overridepublic 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<Integer> threadLocal=new ThreadLocal<Integer>(){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;}@Overridepublic 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();}
}