欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-04-09 20:16:28
synchronized:代码开始上锁,代码结束时释放锁;内置锁、自动化的、效率低、扩展性不高(不够灵活); JDK1.5并发包Lock锁 保证线程安全问题,属于手动挡,手动开始上锁,手动释放锁,灵活性高; Lock 接口与 synchronized 关键字的区别 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();
}
}