精华内容
下载资源
问答
  • 为了解决竞争条件带来的问题,...我们把这种情况称为互斥,即不允许多个线程同时对共享资源进行操作,在同一时间只能被一个线程所占有的锁称之为Java多线程互斥锁。互斥锁在java中的实现就是 ReetranLock , 在访问一...

    为了解决竞争条件带来的问题,我们可以对资源上锁。多个线程共同读写的资源称为共享资源,也叫临界资源。涉及操作临界资源的代码区域称为临界区(Critical Section)。同一时刻,只能有一个线程进入临界区。我们把这种情况称为互斥,即不允许多个线程同时对共享资源进行操作,在同一时间只能被一个线程所占有的锁称之为Java多线程互斥锁。

    互斥锁在java中的实现就是 ReetranLock , 在访问一个同步资源时,它的对象需要通过方法 tryLock() 获得这个锁,如果失败,返回 false,成功返回true。根据返回的信息来判断是否要访问这个被同步的资源。ReentrantLock 互斥锁是可重入锁,即某一线程可多次获得该锁。

    进入临界区前,需要先获得互斥锁。如果已经有线程正在使用资源,那么需要一直等待,直到其它线程归还互斥锁。

    操作完共享资源之后,即退出临界区时,需要归还互斥锁,以便其它等待使用该资源的线程能够进入临界区。

    伪代码示例:

    wait(lock); //获得互斥锁

    {

    临界区,操作共享资源

    }

    signal(lock); //归还互斥锁

    Java 中可以使用 ReentrantLock 对临界区上锁,防止多个线程同时进入临界区:

    private static Lock bufferLock = new ReentrantLock();

    public static void print(String msg) {

    bufferLock.lock();

    //临界区,操作临界资源 globalBuffer

    bufferLock.unlock();

    }

    这里我们只需要在临界区前使用 lock() 上锁,在临界区后使用 unlock() 解锁即可,java.util.concurrent 帮我们实现了临界区前判断锁状态的工作,会自己决定是阻塞还是进入临界区。

    synchronized 关键字

    java 为我们提供了更加简便的方式,用于实现临界区的互斥。

    例如,我们可以为操作共享资源的函数加上 synchronized 关键字:

    public synchronized void myFunction() {

    //操作共享资源 A

    }

    通过这种方式,能够确保同一时刻最多只有一个线程在执行该函数。如果资源 A 只在该函数中读写,那么可以保证资源 A 不会出现被多个线程同时读写的情况。

    但是,如果在其它函数中也对共享资源 A 进行操作,那么就不能使用这种方式来实现资源的使用互斥。因为即使这些函数都声明为 synchronized,也只是说明同一时刻不能有多个线程执行同一个函数,但允许多个线程同时执行不同的函数,而这些函数都在操作同一个资源 A。

    下面我们给出另一种方法来实现资源使用的互斥锁。

    synchronized 代码块

    通过声明函数为 synchronized 的方式,只能实现函数体的互斥。要确保资源使用的互斥,即同一时刻只能有一个线程使用该资源,可以将操作资源 A 的语句放入 synchronized 代码块:

    public void function1() {

    ......

    synchronized (A) {

    //操作资源 A

    }

    ......

    }

    public void function2() {

    ......

    synchronized (A) {

    //操作资源 A

    }

    ......

    }

    这样,对于资源 A 来说,同一时刻,只能有一个对应的 synchronized 代码块执行。因此,无论是在哪个地方使用资源 A,都不会出现多个线程竞争该资源的情况。

    由ReentrantLock 的构造函数可见,在实例化 ReentrantLock 的时候我们可以选择实例化一个公平锁或非公平锁,而默认会构造一个非公平锁。公平锁与非公平锁区别在于竞争锁时的有序与否。Java多线程互斥锁ReentrantLock是通过继承接口Lock而实现的,类似的还有继承 ReadWriteLock 实现的 ReentrantReadWriteLock(读写锁),对此,在本站的Java多线程教程中有进一步的讲解。

    展开全文
  • 什么是互斥锁?在访问共享资源之前对进行加锁操作,在访问完成之后进行解锁操作。 加锁后,任何其他试图再次加锁的线程会被阻塞,直到当前进程解锁。...互斥锁要求只能有一个线程访问被保护的资源,共享锁从...

    什么是互斥锁?

    在访问共享资源之前对进行加锁操作,在访问完成之后进行解锁操作。 加锁后,任何其他试图再次加锁的线程会被阻塞,直到当前进程解锁。

    如果解锁时有一个以上的线程阻塞,那么所有该锁上的线程都被编程就绪状态, 第一个变为就绪状态的线程又执行加锁操作,那么其他的线程又会进入等待。 在这种方式下,只有一个线程能够访问被互斥锁保护的资源。

    什么是共享锁?

    互斥锁要求只能有一个线程访问被保护的资源,共享锁从字面来看也即是允许多个线程共同访问资源。

    什么是读写锁?

    读写锁既是互斥锁,又是共享锁,read模式是共享,write是互斥(排它锁)的。

    读写锁有三种状态:读加锁状态、写加锁状态和不加锁状态

    一次只有一个线程可以占有写模式的读写锁,但是多个线程可以同时占有读模式的读写锁。

    用ReentrantLock手动实现一个简单的读写锁。

    MyReadWriteLock.java

    /**

    * Created by Fant.J.

    */

    public class MyReadWriteLock {

    private Map map = new HashMap<>();

    private ReadWriteLock rwl = new ReentrantReadWriteLock();

    private Lock r = rwl.readLock();

    private Lock w = rwl.writeLock();

    public Object get(String key){

    try {

    r.lock();

    System.out.println(Thread.currentThread().getName()+"read 操作执行");

    Thread.sleep(500);

    return map.get(key);

    } catch (InterruptedException e) {

    e.printStackTrace();

    return null;

    } finally {

    r.unlock();

    System.out.println(Thread.currentThread().getName()+"read 操作结束");

    }

    }

    public void put(String key,Object value){

    try {

    w.lock();

    System.out.println(Thread.currentThread().getName()+"write 操作执行");

    Thread.sleep(500);

    map.put(key,value);

    } catch (InterruptedException e) {

    e.printStackTrace();

    } finally {

    w.unlock();

    System.out.println(Thread.currentThread().getName()+"write 操作结束");

    }

    }

    }

    测试读读共享(不互斥)

    /**

    * Created by Fant.J.

    */

    public class Test {

    public static void main(String[] args) {

    MyReadWriteLock myReadWriteLock = new MyReadWriteLock();

    myReadWriteLock.put("a","fantj_a");

    //读读不互斥(共享)

    //读写互斥

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    }

    }

    mainwrite 操作执行

    mainwrite 操作结束

    Thread-1read 操作执行

    Thread-2read 操作执行

    Thread-0read 操作执行

    Thread-3read 操作执行

    Thread-4read 操作执行

    Thread-5read 操作执行

    Thread-1read 操作结束

    Thread-0read 操作结束

    Thread-2read 操作结束

    Thread-3read 操作结束

    fantj_a

    fantj_a

    fantj_a

    fantj_a

    Thread-4read 操作结束

    fantj_a

    Thread-5read 操作结束

    fantj_a

    可以看出,中间有很多read操作是并发进行的。

    那么我们再看下写写是否有互斥性:

    /**

    * 测试 写-写 模式 是互斥的

    * Created by Fant.J.

    */

    public class TestWriteWrite {

    public static void main(String[] args) {

    MyReadWriteLock myReadWriteLock = new MyReadWriteLock();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    }

    }

    Thread-0write 操作执行

    Thread-1write 操作执行

    Thread-0write 操作结束

    Thread-1write 操作结束

    Thread-2write 操作执行

    Thread-2write 操作结束

    Thread-3write 操作执行

    Thread-3write 操作结束

    Thread-4write 操作执行

    Thread-4write 操作结束

    控制台能明显感觉到线程休息的时间。所以它的写-写操作肯定是互斥的。

    最后再看看,写-读 操作是否互斥。

    写-读互斥 测试

    /**

    * 测试 写-读模式 互斥

    * Created by Fant.J.

    */

    public class TestWriteRead {

    public static void main(String[] args) {

    MyReadWriteLock myReadWriteLock = new MyReadWriteLock();

    //读读不互斥(共享)

    //读写互斥

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("a","fantj_a");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    }

    }

    Thread-0write 操作执行

    Thread-1read 操作执行

    Thread-0write 操作结束

    Thread-1read 操作结束

    fantj_a

    控制台可以看到write操作执行后线程被阻塞。直到写释放了锁。

    问题分析

    问题1:仔细想了想,如果有一种场景,就是用户一直再读,写获取不到锁,那么不就造成脏读吗?

    上一章我介绍了公平锁/非公平锁,资源的抢占不就是非公平锁造成的吗,那我们用公平锁把它包装下不就能避免了吗,我做了个简单的实现:(不知道公平锁的可以翻我上章教程)

    /**

    * 测试 读写锁 的公平锁 实现

    * Created by Fant.J.

    */

    public class TestReadWriteRead {

    public static void main(String[] args) {

    ReentrantLock fairLock = new ReentrantLock(true);

    MyReadWriteLock myReadWriteLock = new MyReadWriteLock();

    myReadWriteLock.put("a","fantj_a");

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    System.out.println(myReadWriteLock.get("a"));

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    System.out.println(myReadWriteLock.get("a"));

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    System.out.println(myReadWriteLock.get("a"));

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    myReadWriteLock.put("a","fantj_a_update");

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    System.out.println(myReadWriteLock.get("a"));

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    }

    }

    mainwrite 操作执行

    mainwrite 操作结束

    Thread-0read 操作执行

    Thread-0read 操作结束

    fantj_a

    fair队列长度4

    Thread-1read 操作执行

    Thread-1read 操作结束

    fantj_a

    fair队列长度3

    Thread-2read 操作执行

    Thread-2read 操作结束

    fantj_a

    fair队列长度2

    Thread-3write 操作执行

    Thread-3write 操作结束

    fair队列长度1

    Thread-4read 操作执行

    Thread-4read 操作结束

    fantj_a_update

    fair队列长度0

    如果谁有更好的实现方式(或者java有现成的实现工具类/包),可在评论区留言,我在百度上没有找到读写锁的公平锁实现~~谢谢!

    展开全文
  • 本章对ReentrantLock包进行基本介绍,这一章主要对ReentrantLock进行概括性的介绍,内容包括:ReentrantLock介绍ReentrantLock函数...ReentrantLock介绍ReentrantLock是一个可重入的互斥锁,又被称为“独占锁”。顾...

    本章对ReentrantLock包进行基本介绍,这一章主要对ReentrantLock进行概括性的介绍,内容包括:

    ReentrantLock介绍

    ReentrantLock函数列表

    ReentrantLock示例

    在后面的两章,会分别介绍ReentrantLock的两个子类(公平锁和非公平锁)的实现原理。

    ReentrantLock介绍

    ReentrantLock是一个可重入的互斥锁,又被称为“独占锁”。

    顾名思义,ReentrantLock锁在同一个时间点只能被一个线程锁持有;而可重入的意思是,ReentrantLock锁,可以被单个线程多次获取。

    ReentrantLock分为“公平锁”和“非公平锁”。它们的区别体现在获取锁的机制上是否公平。“锁”是为了保护竞争资源,防止多个线程同时操作线程而出错,ReentrantLock在同一个时间点只能被一个线程获取(当某线程获取到“锁”时,其它线程就必须等待);ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下,线程依次排队获取锁;而“非公平锁”在锁是可获取状态时,不管自己是不是在队列的开头都会获取锁。

    ReentrantLock函数列表

    //创建一个 ReentrantLock ,默认是“非公平锁”。

    ReentrantLock()//创建策略是fair的 ReentrantLock。fair为true表示是公平锁,fair为false表示是非公平锁。

    ReentrantLock(booleanfair)//查询当前线程保持此锁的次数。

    intgetHoldCount()//返回目前拥有此锁的线程,如果此锁不被任何线程拥有,则返回 null。

    protectedThread getOwner()//返回一个 collection,它包含可能正等待获取此锁的线程。

    protected CollectiongetQueuedThreads()//返回正等待获取此锁的线程估计数。

    intgetQueueLength()//返回一个 collection,它包含可能正在等待与此锁相关给定条件的那些线程。

    protected CollectiongetWaitingThreads(Condition condition)//返回等待与此锁相关的给定条件的线程估计数。

    intgetWaitQueueLength(Condition condition)//查询给定线程是否正在等待获取此锁。

    booleanhasQueuedThread(Thread thread)//查询是否有些线程正在等待获取此锁。

    booleanhasQueuedThreads()//查询是否有些线程正在等待与此锁有关的给定条件。

    booleanhasWaiters(Condition condition)//如果是“公平锁”返回true,否则返回false。

    booleanisFair()//查询当前线程是否保持此锁。

    booleanisHeldByCurrentThread()//查询此锁是否由任意线程保持。

    booleanisLocked()//获取锁。

    voidlock()//如果当前线程未被中断,则获取锁。

    voidlockInterruptibly()//返回用来与此 Lock 实例一起使用的 Condition 实例。

    Condition newCondition()//仅在调用时锁未被另一个线程保持的情况下,才获取该锁。

    booleantryLock()//如果锁在给定等待时间内没有被另一个线程保持,且当前线程未被中断,则获取该锁。

    boolean tryLock(longtimeout, TimeUnit unit)//试图释放此锁。

    void unlock()

    ReentrantLock示例

    通过对比“示例1”和“示例2”,我们能够清晰的认识lock和unlock的作用

    示例1

    1 importjava.util.concurrent.locks.Lock;2 importjava.util.concurrent.locks.ReentrantLock;3

    4 //LockTest1.java5 //仓库

    6 classDepot {7 private int size; //仓库的实际数量

    8 private Lock lock; //独占锁

    9

    10 publicDepot() {11 this.size = 0;12 this.lock = newReentrantLock();13 }14

    15 public void produce(intval) {16 lock.lock();17 try{18 size +=val;19 System.out.printf("%s produce(%d) --> size=%d\n",20 Thread.currentThread().getName(), val, size);21 } finally{22 lock.unlock();23 }24 }25

    26 public void consume(intval) {27 lock.lock();28 try{29 size -=val;30 System.out.printf("%s consume(%d)

    38 //生产者

    39 classProducer {40 privateDepot depot;41

    42 publicProducer(Depot depot) {43 this.depot =depot;44 }45

    46 //消费产品:新建一个线程向仓库中生产产品。

    47 public void produce(final intval) {48 newThread() {49 public voidrun() {50 depot.produce(val);51 }52 }.start();53 }54 }55

    56 //消费者

    57 classCustomer {58 privateDepot depot;59

    60 publicCustomer(Depot depot) {61 this.depot =depot;62 }63

    64 //消费产品:新建一个线程从仓库中消费产品。

    65 public void consume(final intval) {66 newThread() {67 public voidrun() {68 depot.consume(val);69 }70 }.start();71 }72 }73

    74 public classLockTest1 {75 public static voidmain(String[] args) {76 Depot mDepot = newDepot();77 Producer mPro = newProducer(mDepot);78 Customer mCus = newCustomer(mDepot);79

    80 mPro.produce(60);81 mPro.produce(120);82 mCus.consume(90);83 mCus.consume(150);84 mPro.produce(110);85 }86 }

    运行结果:

    Thread-0 produce(60) --> size=60Thread-1 produce(120) --> size=180Thread-3 consume(150) size=50

    结果分析:

    (01) Depot 是个仓库。通过produce()能往仓库中生产货物,通过consume()能消费仓库中的货物。通过独占锁lock实现对仓库的互斥访问:在操作(生产/消费)仓库中货品前,会先通过lock()锁住仓库,操作完之后再通过unlock()解锁。

    (02) Producer是生产者类。调用Producer中的produce()函数可以新建一个线程往仓库中生产产品。

    (03) Customer是消费者类。调用Customer中的consume()函数可以新建一个线程消费仓库中的产品。

    (04) 在主线程main中,我们会新建1个生产者mPro,同时新建1个消费者mCus。它们分别向仓库中生产/消费产品。

    根据main中的生产/消费数量,仓库最终剩余的产品应该是50。运行结果是符合我们预期的!

    这个模型存在两个问题:

    (01) 现实中,仓库的容量不可能为负数。但是,此模型中的仓库容量可以为负数,这与现实相矛盾!

    (02) 现实中,仓库的容量是有限制的。但是,此模型中的容量确实没有限制的!

    这两个问题,我们稍微会讲到如何解决。现在,先看个简单的示例2;通过对比“示例1”和“示例2”,我们能更清晰的认识lock(),unlock()的用途。

    示例2

    1 importjava.util.concurrent.locks.Lock;2 importjava.util.concurrent.locks.ReentrantLock;3

    4 //LockTest2.java5 //仓库

    6 classDepot {7 private int size; //仓库的实际数量

    8 private Lock lock; //独占锁

    9

    10 publicDepot() {11 this.size = 0;12 this.lock = newReentrantLock();13 }14

    15 public void produce(intval) {16 //lock.lock();17 //try {

    18 size +=val;19 System.out.printf("%s produce(%d) --> size=%d\n",20 Thread.currentThread().getName(), val, size);21 //} catch (InterruptedException e) {22 //} finally {23 //lock.unlock();24 //}

    25 }26

    27 public void consume(intval) {28 //lock.lock();29 //try {

    30 size -=val;31 System.out.printf("%s consume(%d)

    36 }37 };38

    39 //生产者

    40 classProducer {41 privateDepot depot;42

    43 publicProducer(Depot depot) {44 this.depot =depot;45 }46

    47 //消费产品:新建一个线程向仓库中生产产品。

    48 public void produce(final intval) {49 newThread() {50 public voidrun() {51 depot.produce(val);52 }53 }.start();54 }55 }56

    57 //消费者

    58 classCustomer {59 privateDepot depot;60

    61 publicCustomer(Depot depot) {62 this.depot =depot;63 }64

    65 //消费产品:新建一个线程从仓库中消费产品。

    66 public void consume(final intval) {67 newThread() {68 public voidrun() {69 depot.consume(val);70 }71 }.start();72 }73 }74

    75 public classLockTest2 {76 public static voidmain(String[] args) {77 Depot mDepot = newDepot();78 Producer mPro = newProducer(mDepot);79 Customer mCus = newCustomer(mDepot);80

    81 mPro.produce(60);82 mPro.produce(120);83 mCus.consume(90);84 mCus.consume(150);85 mPro.produce(110);86 }87 }

    (某一次)运行结果:

    Thread-0 produce(60) --> size=-60Thread-4 produce(110) --> size=50Thread-2 consume(90) size=-60Thread-3 consume(150)

    结果说明:

    “示例2”在“示例1”的基础上去掉了lock锁。在“示例2”中,仓库中最终剩余的产品是-60,而不是我们期望的50。原因是我们没有实现对仓库的互斥访问。

    示例3

    在“示例3”中,我们通过Condition去解决“示例1”中的两个问题:“仓库的容量不可能为负数”以及“仓库的容量是有限制的”。

    解决该问题是通过Condition。Condition是需要和Lock联合使用的:通过Condition中的await()方法,能让线程阻塞[类似于wait()];通过Condition的signal()方法,能让唤醒线程[类似于notify()]。

    1 importjava.util.concurrent.locks.Lock;2 importjava.util.concurrent.locks.ReentrantLock;3 importjava.util.concurrent.locks.Condition;4

    5 //LockTest3.java6 //仓库

    7 classDepot {8 private int capacity; //仓库的容量

    9 private int size; //仓库的实际数量

    10 private Lock lock; //独占锁

    11 private Condition fullCondtion; //生产条件

    12 private Condition emptyCondtion; //消费条件

    13

    14 public Depot(intcapacity) {15 this.capacity =capacity;16 this.size = 0;17 this.lock = newReentrantLock();18 this.fullCondtion =lock.newCondition();19 this.emptyCondtion =lock.newCondition();20 }21

    22 public void produce(intval) {23 lock.lock();24 try{25 //left 表示“想要生产的数量”(有可能生产量太多,需多此生产)

    26 int left =val;27 while (left > 0) {28 //库存已满时,等待“消费者”消费产品。

    29 while (size >=capacity)30 fullCondtion.await();31 //获取“实际生产的数量”(即库存中新增的数量)32 //如果“库存”+“想要生产的数量”>“总的容量”,则“实际增量”=“总的容量”-“当前容量”。(此时填满仓库)33 //否则“实际增量”=“想要生产的数量”

    34 int inc = (size+left)>capacity ? (capacity-size) : left;35 size +=inc;36 left -=inc;37 System.out.printf("%s produce(%3d) --> left=%3d, inc=%3d, size=%3d\n",38 Thread.currentThread().getName(), val, left, inc, size);39 //通知“消费者”可以消费了。

    40 emptyCondtion.signal();41 }42 } catch(InterruptedException e) {43 } finally{44 lock.unlock();45 }46 }47

    48 public void consume(intval) {49 lock.lock();50 try{51 //left 表示“客户要消费数量”(有可能消费量太大,库存不够,需多此消费)

    52 int left =val;53 while (left > 0) {54 //库存为0时,等待“生产者”生产产品。

    55 while (size <= 0)56 emptyCondtion.await();57 //获取“实际消费的数量”(即库存中实际减少的数量)58 //如果“库存”

    60 int dec = (size

    73 publicString toString() {74 return "capacity:"+capacity+", actual size:"+size;75 }76 };77

    78 //生产者

    79 classProducer {80 privateDepot depot;81

    82 publicProducer(Depot depot) {83 this.depot =depot;84 }85

    86 //消费产品:新建一个线程向仓库中生产产品。

    87 public void produce(final intval) {88 newThread() {89 public voidrun() {90 depot.produce(val);91 }92 }.start();93 }94 }95

    96 //消费者

    97 classCustomer {98 privateDepot depot;99

    100 publicCustomer(Depot depot) {101 this.depot =depot;102 }103

    104 //消费产品:新建一个线程从仓库中消费产品。

    105 public void consume(final intval) {106 newThread() {107 public voidrun() {108 depot.consume(val);109 }110 }.start();111 }112 }113

    114 public classLockTest3 {115 public static voidmain(String[] args) {116 Depot mDepot = new Depot(100);117 Producer mPro = newProducer(mDepot);118 Customer mCus = newCustomer(mDepot);119

    120 mPro.produce(60);121 mPro.produce(120);122 mCus.consume(90);123 mCus.consume(150);124 mPro.produce(110);125 }126 }

    (某一次)运行结果:

    Thread-0 produce( 60) --> left= 0, inc= 60, size= 60Thread-1 produce(120) --> left= 80, inc= 40, size=100Thread-2 consume( 90) left= 10, inc=100, size=100Thread-3 consume(150) left= 0, inc= 10, size= 10Thread-3 consume(150) left= 0, inc= 80, size= 80Thread-3 consume(150)

    代码中的已经包含了很详细的注释,这里就不再说明了。

    而关于Condition的内容,在后面我们会详细介绍。

    更多内容

    展开全文
  • 什么是互斥锁?在访问共享资源之前对进行加锁操作,在访问完成之后进行解锁操作。 加锁后,任何其他试图再次加锁的线程会被阻塞,直到当前进程解锁。...互斥锁要求只能有一个线程访问被保护的资源,共享锁从...

    什么是互斥锁?

    在访问共享资源之前对进行加锁操作,在访问完成之后进行解锁操作。 加锁后,任何其他试图再次加锁的线程会被阻塞,直到当前进程解锁。

    如果解锁时有一个以上的线程阻塞,那么所有该锁上的线程都被编程就绪状态, 第一个变为就绪状态的线程又执行加锁操作,那么其他的线程又会进入等待。 在这种方式下,只有一个线程能够访问被互斥锁保护的资源。

    什么是共享锁?

    互斥锁要求只能有一个线程访问被保护的资源,共享锁从字面来看也即是允许多个线程共同访问资源。

    什么是读写锁?

    读写锁既是互斥锁,又是共享锁,read模式是共享,write是互斥(排它锁)的。

    读写锁有三种状态:读加锁状态、写加锁状态和不加锁状态

    一次只有一个线程可以占有写模式的读写锁,但是多个线程可以同时占有读模式的读写锁。

    用ReentrantLock手动实现一个简单的读写锁。

    MyReadWriteLock.java

    /**

    * Created by Fant.J.

    */

    public class MyReadWriteLock {

    private Map map = new HashMap<>();

    private ReadWriteLock rwl = new ReentrantReadWriteLock();

    private Lock r = rwl.readLock();

    private Lock w = rwl.writeLock();

    public Object get(String key){

    try {

    r.lock();

    System.out.println(Thread.currentThread().getName()+"read 操作执行");

    Thread.sleep(500);

    return map.get(key);

    } catch (InterruptedException e) {

    e.printStackTrace();

    return null;

    } finally {

    r.unlock();

    System.out.println(Thread.currentThread().getName()+"read 操作结束");

    }

    }

    public void put(String key,Object value){

    try {

    w.lock();

    System.out.println(Thread.currentThread().getName()+"write 操作执行");

    Thread.sleep(500);

    map.put(key,value);

    } catch (InterruptedException e) {

    e.printStackTrace();

    } finally {

    w.unlock();

    System.out.println(Thread.currentThread().getName()+"write 操作结束");

    }

    }

    }

    测试读读共享(不互斥)

    /**

    * Created by Fant.J.

    */

    public class Test {

    public static void main(String[] args) {

    MyReadWriteLock myReadWriteLock = new MyReadWriteLock();

    myReadWriteLock.put("a","fantj_a");

    //读读不互斥(共享)

    //读写互斥

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    }

    }

    mainwrite 操作执行

    mainwrite 操作结束

    Thread-1read 操作执行

    Thread-2read 操作执行

    Thread-0read 操作执行

    Thread-3read 操作执行

    Thread-4read 操作执行

    Thread-5read 操作执行

    Thread-1read 操作结束

    Thread-0read 操作结束

    Thread-2read 操作结束

    Thread-3read 操作结束

    fantj_a

    fantj_a

    fantj_a

    fantj_a

    Thread-4read 操作结束

    fantj_a

    Thread-5read 操作结束

    fantj_a

    可以看出,中间有很多read操作是并发进行的。

    那么我们再看下写写是否有互斥性:

    /**

    * 测试 写-写 模式 是互斥的

    * Created by Fant.J.

    */

    public class TestWriteWrite {

    public static void main(String[] args) {

    MyReadWriteLock myReadWriteLock = new MyReadWriteLock();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("b","fantj_b");

    }

    }).start();

    }

    }

    Thread-0write 操作执行

    Thread-1write 操作执行

    Thread-0write 操作结束

    Thread-1write 操作结束

    Thread-2write 操作执行

    Thread-2write 操作结束

    Thread-3write 操作执行

    Thread-3write 操作结束

    Thread-4write 操作执行

    Thread-4write 操作结束

    控制台能明显感觉到线程休息的时间。所以它的写-写操作肯定是互斥的。

    最后再看看,写-读 操作是否互斥。

    写-读互斥 测试

    /**

    * 测试 写-读模式 互斥

    * Created by Fant.J.

    */

    public class TestWriteRead {

    public static void main(String[] args) {

    MyReadWriteLock myReadWriteLock = new MyReadWriteLock();

    //读读不互斥(共享)

    //读写互斥

    new Thread(new Runnable() {

    @Override

    public void run() {

    myReadWriteLock.put("a","fantj_a");

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    System.out.println(myReadWriteLock.get("a"));

    }

    }).start();

    }

    }

    Thread-0write 操作执行

    Thread-1read 操作执行

    Thread-0write 操作结束

    Thread-1read 操作结束

    fantj_a

    控制台可以看到write操作执行后线程被阻塞。直到写释放了锁。

    问题分析

    问题1:仔细想了想,如果有一种场景,就是用户一直再读,写获取不到锁,那么不就造成脏读吗?

    上一章我介绍了公平锁/非公平锁,资源的抢占不就是非公平锁造成的吗,那我们用公平锁把它包装下不就能避免了吗,我做了个简单的实现:(不知道公平锁的可以翻我上章教程)

    /**

    * 测试 读写锁 的公平锁 实现

    * Created by Fant.J.

    */

    public class TestReadWriteRead {

    public static void main(String[] args) {

    ReentrantLock fairLock = new ReentrantLock(true);

    MyReadWriteLock myReadWriteLock = new MyReadWriteLock();

    myReadWriteLock.put("a","fantj_a");

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    System.out.println(myReadWriteLock.get("a"));

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    System.out.println(myReadWriteLock.get("a"));

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    System.out.println(myReadWriteLock.get("a"));

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    myReadWriteLock.put("a","fantj_a_update");

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    new Thread(new Runnable() {

    @Override

    public void run() {

    fairLock.lock();

    System.out.println(myReadWriteLock.get("a"));

    System.out.println("fair队列长度"+fairLock.getQueueLength());

    fairLock.unlock();

    }

    }).start();

    }

    }

    mainwrite 操作执行

    mainwrite 操作结束

    Thread-0read 操作执行

    Thread-0read 操作结束

    fantj_a

    fair队列长度4

    Thread-1read 操作执行

    Thread-1read 操作结束

    fantj_a

    fair队列长度3

    Thread-2read 操作执行

    Thread-2read 操作结束

    fantj_a

    fair队列长度2

    Thread-3write 操作执行

    Thread-3write 操作结束

    fair队列长度1

    Thread-4read 操作执行

    Thread-4read 操作结束

    fantj_a_update

    fair队列长度0

    如果谁有更好的实现方式(或者java有现成的实现工具类/包),可在评论区留言,我在百度上没有找到读写锁的公平锁实现~~谢谢!

    展开全文
  • 多线程(JDK1.5的新特性互斥锁)* 1.同步* 使用ReentrantLock类的lock()和unlock()方法进行同步* 2.通信* 使用ReentrantLock类的newCondition()方法可以获取Condition对象* 需要等待的时候使用Condition的await()方法,...
  • 主要介绍了Java多线程 ReentrantLock互斥锁详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 引入互斥锁即解决多个线程之间共享同一个共享资源,这是多线程编程需要考虑的一个问题。 互斥锁 互斥锁又称互斥型信号量,是一种特殊的二值性信号量,用于实现对共享资源的独占式处理。 任意时刻互斥锁的状态只有两...
  • 一个多线程访问的同一个资源,java synchronized互斥锁的用法,android和此用法一致。
  • 常用的有互斥锁、自旋锁和读写锁。自旋锁和互斥锁功在使用时差不多,每一时刻只能有一个执行单元占有锁,而占有锁的单元才能获得临界资源的使用权,从而达到了互斥的目的。自旋锁与互斥锁的区别在于:自旋锁在执行...
  • 两种互斥锁机制:1、synchronized2、ReentrantLockReentrantLock是jdk5的新特性,采用ReentrantLock可以完全替代替换synchronized传统的锁机制,而且采用ReentrantLock的方式更加面向对象,也更加灵活,网上有很...
  • 多线程(JDK1.5的新特性互斥锁)* 1.同步* 使用ReentrantLock类的lock()和unlock()方法进行同步* 2.通信* 使用ReentrantLock类的newCondition()方法可以获取Condition对象* 需要等待的时候使用Condition的await()方法,...
  • 慕课网上学习了java 多线程应用。 根据课中的 多线程数据争用 自己重写一遍代码EnergySystem.classpackage Energy;public class EnergySystem { private final double energybox[] ; EnergySystem(double totalE ,...
  • 当使用完syncharonized的方法运行完这个线程后,就会释放 线程互斥机制称之为监视(monitor),另外,获取有时候也叫做拥有(own)监视或者持有(hold)。 当前线程是否已获得某一个对象的可以通过Thread....
  • wait方法的调用会让当前线程放弃已经获取的object标志位,比如在同步代码块synchronized中调用wait(),则表示当前线程被唤醒之后需要重新获取同步代码块的。另外wait/notify由于要操作对象...
  • 互斥锁: 在上节中我们谈到了Object类的notify()方法随机唤醒单个线程,而不是唤醒指定线程,这就会导致一个问题,比如三个线程A,B,C,A在执行线程体,B,C在等待,A执行完该B执行了,notify方法随机唤醒一个线程,显然不能用...
  • 0.关于互斥锁所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制线程对共享资源的访问. 而现在, Lock提供了比synchronized机制更广泛的锁定操作, Lock和...
  • 0.关于互斥锁所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制线程对共享资源的访问. 而现在, Lock提供了比synchronized机制更广泛的锁定操作, Lock和...
  • Java多线程并发的程序中使用互斥锁有synchronized和ReentrantLock两种方式,这里我们来详解Java多线程编程中互斥锁ReentrantLock类的用法:
  • 在看线程同步的问题之前,我们先看一个生活中的小例子:我拿着银行卡去ATM取钱,假如我的卡里有3000块,我要取走2000,这个时候,ATM会去银行的数据库里查询我的账户是否有2000以上的余额,如果有,就会让我取走,...
  • 常用的有互斥锁、自旋锁和读写锁。 自旋锁和互斥锁功在使用时差不多,每一时刻只能有一个执行单元占有锁,而占有锁的单元才能获得临界资源的使用权,从而达到了互斥的目的。 自旋锁与互斥锁的区别在于:自旋锁在...
  • 线程互斥机制称之为监视(monitor),另外,获取有时候也叫做拥有(own)监视或者持有(hold)。 当前线程是否已获得某一个对象的可以通过Thread.holdsLock方法来确定。当前线程已经获得对象obj的时,可...
  • 多线程线程是计算机中独立运行的最小单位,运行时占用很少的系统资源。与多进程相比,多进程具有多进程不具备的一些优点,其最重要的是:对于多线程来说,其能够比多进程更加节省资源。1、线程创建在Linux中,新建的...
  • 主要介绍了Java编程中的互斥锁,信号量和多线程等待机制实例详解,简单介绍了互斥锁和信号量的区别,需要的朋友可以了解下。
  • Java 中的通常分为两种:通过关键字 synchronized 获取的,我们称为同步,上一篇有介绍到:Java 多线程并发编程 Synchronized 关键字。java.util.concurrent(JUC)包里的,如通过继承接口 Lock 而实现的 ...
  • 也就是说,信号量可以使资源同时被线程访问,而互斥锁同时只能被一个线程访问互斥锁java中的实现就是 ReetranLock , 在访问一个同步资源时,它的对象需要通过方法 tryLock() 获得这个锁,如果失败,返回 false...
  • 前言 上一篇文章,我们一起学习了synchronized关键字控制的同步锁,从...ReentrantLock是一个可重入的互斥锁,又被称为“独占锁”,可重入的意思是,ReentrantLock锁可以被单个线程多次获取,“独占锁”的意思是,在...
  • java线程互斥锁与读写锁

    千次阅读 2015-01-18 02:38:03
    两种互斥锁机制: 1、synchronized 2、ReentrantLock ReentrantLock是jdk5的新特性,采用ReentrantLock可以完全替代替换synchronized传统的锁机制,而且采用ReentrantLock的方式更加面向对象,也更加灵活,...
  • 两种互斥锁机制: 1、synchronized 2、ReentrantLock ReentrantLock是jdk5的新特性,采用ReentrantLock可以完全替代替换synchronized传统的锁机制,而且采用 ReentrantLock的方式更加面向对象,也更加灵活...
  • 通过关键字 synchronized 获取的锁,我们称为同步锁,Java 多线程并发编程 Synchronized 关键字。 java.util.concurrent(JUC)包里的锁,如通过继承接口 Lock 而实现的 ReentrantLock(互斥锁),继承 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,734
精华内容 1,093
关键字:

java多线程互斥锁

java 订阅