Java多线程--04

Lock锁的介绍：
synchronized 是在代码开始的是上锁的，在代码结束的时候释放锁的资源的。
在JDK1.5中并发包lock锁保证线程安全问题。
lock锁和synchronized同步锁。
lock是手动加锁，手动释放锁。
多线程并发：指的是多个Thread同时操作一个资源。
网站并发：多个请求同时请求同台服务器。
给代码加锁：

 Lock lock = new ReentrantLock();
  user.lock.lock();

给代码释放锁：

 user.lock.unlock();

lock锁代码演示：

package com.itmayiedu.day03;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 共享资源的线程。。
 */
public class User {
    private String userName;
    private String Sex;
    public boolean flag = false;//设置一个标示 当前当前的状态
    Lock lock = new ReentrantLock();
    Condition condition;
    public String getUserName() {
        return userName;
    }

    public String getSex() {
        return Sex;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setSex(String sex) {
        Sex = sex;
    }

}

给实体对象赋值：

package com.itmayiedu.day03;

import java.util.concurrent.locks.Condition;

public class OutThread02 implements Runnable {
  private int count = 0;
  Condition condition;
   User user;
   public OutThread02(User user,Condition condition){
       this.user =user;
       this.condition =condition;
   }



    @Override
    public void run() {
        while (true){
            user.lock.lock();
            if(user.flag){//如果是true 的表示等待
               try{
                 condition.await();
               }catch (Exception ex){

               }
            }
            try{
               if(count==0){
                   user.setSex("女");
                   user.setUserName("曹永芳");
               }else{
                   user.setUserName("闫天蓬");
                   user.setSex("男");
               }
               count =(count+1)%2;
               user.flag = true;
              condition.signal();
           }catch (Exception ex){

           }finally {
               user.lock.unlock();

           }
        }
    }
}

读取实体对象的值：

package com.itmayiedu.day03;

import java.util.concurrent.locks.Condition;

public class inputThread01 implements Runnable {
    User user;
    Condition condition;
    public inputThread01(User user,Condition condition){
        this.user =user;
        this.condition =condition;
    }

    @Override
    public void run() {
       try{
           user.lock.lock();//线程上锁
           if(!user.flag){//false 标示线程在等待
               condition.await();
           }
           System.out.println("姓名："+user.getUserName()+":性别："+user.getSex());
           user.flag =false;
           condition.signal();
       }catch (Exception ex){

       }finally {
          user.lock.unlock();//线程释放锁
       }
    }


}

测试类：

package com.itmayiedu.day03;

import java.util.concurrent.locks.Condition;

public class TestThread01 {
    public static void main(String[] args) {
        User user = new User();
        Condition condition =user.lock.newCondition();
        inputThread01 inputThread01 = new inputThread01(user,condition);
        OutThread02 outThread02 = new OutThread02(user,condition);
        Thread thread1 = new Thread(inputThread01);
        Thread thread2 = new Thread(outThread02);
        thread1.start();
        thread2.start();
    }
}

lock锁和synchronized关键字的区别：
lock接口可以尝试非阻塞地获取锁，当前线程尝试获取锁。如果这一时刻没有被线程获取到，则可以成功获取并持有锁。
lock接口能被中断地获取锁与synchronzied不同，获取到锁的线程可以相应中断，当获取到锁的线程被中断时，中断异常将会抛出，同时锁会被释放。
lock接口在指定的截止时间之前获取锁，如果截止时间到了依旧无法获取锁，则返回。
线程的停止：
可以使用stop()方法来停止线程。但是在jdk中stop方法已经被废弃了。stop()方法是不安全的，也是不可恢复的。
在多线程操作中一般是自定义线程的停止：

package com.itmayiedu.day03;

public class StopThread01 extends Thread {
   private   volatile boolean flag = true;  //设置线程的可见性

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

         }
         System.out.println("子线程执行结束。。。。。。");
    }

/**
* 自定义StopThread()方法 设置falg = false；以便可以顺利的通知线程。
/
    public void stopThread(){
        System.out.println("调用stopThread方法");
        this.flag =false;
        System.out.println("修改flag的值为："+flag);
    }
}

ThreadLocal：线程本地变量，为每一个线程提供一个局部变量。