Maison> Java> JavaBase> le corps du texte

Explication détaillée de la programmation simultanée Java

Libérer: 2019-12-25 17:12:11
avant
2522 Les gens l'ont consulté

Explication détaillée de la programmation simultanée Java

1. Les défauts de synchronisé

synchronisé est un mot-clé en java, c'est-à-dire Il est une fonctionnalité intégrée du langage Java. Alors pourquoi Lock apparaît-il ?

Si un bloc de code est modifié par synchronisé, lorsqu'un thread acquiert le verrou correspondant et exécute le bloc de code, les autres threads ne peuvent qu'attendre que le thread qui a acquis le verrou libère le verrou, et l'obtiennent ici. Il n'y a que deux situations où le thread du verrou libère le verrou :

1) Le thread qui a acquis le verrou termine l'exécution du bloc de code, puis le thread libère sa possession du verrou

2 ; ) Une exception se produit lors de l'exécution du thread, à ce moment-là, la JVM laissera le thread libérer automatiquement le verrou.

Recommandé :Tutoriel de base Java

Ensuite, si le thread qui acquiert le verrou est bloqué en raison de l'attente d'IO ou d'autres raisons (telles que l'appel de la méthode sleep), mais ce n'est pas le cas. Après avoir libéré le verrou, les autres threads ne peuvent qu'attendre sèchement. Imaginez comment cela affecte l'efficacité de l'exécution du programme.

Par conséquent, il est nécessaire d'avoir un mécanisme qui empêche les threads en attente d'attendre indéfiniment (par exemple, attendre seulement un certain temps ou pouvoir répondre aux interruptions), ce qui peut être fait via Lock.

Un autre exemple : lorsque plusieurs threads lisent et écrivent des fichiers, les opérations de lecture et les opérations d'écriture entrent en conflit, les opérations d'écriture entrent en conflit avec les opérations d'écriture, mais les opérations de lecture et les opérations de lecture ne se produisent pas.

Mais utiliser le mot-clé synchronisé pour réaliser la synchronisation entraînera un problème :

Si plusieurs threads effectuent uniquement des opérations de lecture, donc lorsqu'un thread effectue une opération de lecture, les autres threads ne peuvent qu'attendre et ne peut pas effectuer d'opérations de lecture.

Par conséquent, un mécanisme est nécessaire pour éviter les conflits entre les threads lorsque plusieurs threads effectuent uniquement des opérations de lecture. Cela peut être fait via Lock.

De plus, Lock peut être utilisé pour savoir si le thread a réussi à acquérir le verrou. C'est quelque chose que la synchronisation ne peut pas faire.

Pour résumer, Lock offre plus de fonctions que synchronisées. Mais faites attention aux points suivants :

1) Le verrouillage n'est pas intégré au langage Java. synchronisé est un mot-clé du langage Java, c'est donc une fonctionnalité intégrée. Lock est une classe à travers laquelle un accès synchrone peut être obtenu ;

2) Il existe une très grande différence entre Lock et synchronisé. L'utilisation de synchronisé ne nécessite pas que l'utilisateur libère manuellement le verrou lorsque la méthode synchronisée est utilisée. Le bloc de code est exécuté, après cela, le système laissera automatiquement le thread libérer le verrou ; avec Lock, l'utilisateur doit libérer manuellement le verrou. Si le verrou n'est pas activement libéré, un blocage peut se produire.

2. Classes couramment utilisées sous le package java.util.concurrent.locks

Parlons des classes java.util.concurrent. et les interfaces dans le package locks.

1.Lock

La première chose à expliquer est Lock En regardant le code source de Lock, on peut voir que Lock est une interface :

public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); Condition newCondition(); }
Copier après la connexion

Passons-les un par un. Décrivons l'utilisation de chaque méthode dans l'interface Lock. lock(), tryLock(), tryLock(long time, TimeUnit unit) et lockInterruptably() sont utilisés pour obtenir des verrous. La méthode unLock() est utilisée pour libérer le verrou. La méthode newCondition() ne sera pas décrite ici pour le moment, mais sera abordée dans un article ultérieur sur la collaboration entre threads.

Quatre méthodes sont déclarées dans Lock pour obtenir le verrou, alors quelles sont les différences entre ces quatre méthodes ?

Tout d'abord, la méthode lock() est la méthode la plus couramment utilisée pour obtenir des verrous. Si le verrou a été acquis par un autre thread, attendez.

Comme mentionné précédemment, si vous utilisez Lock, vous devez activement libérer le verrou, et lorsqu'une exception se produit, le verrou ne sera pas automatiquement libéré. Par conséquent, de manière générale, l'utilisation de Lock doit être effectuée dans le bloc try{}catch{}, et l'opération de libération du verrou doit être effectuée dans le bloc final pour garantir que le verrou doit être libéré et empêcher l'apparition d'impasse. Si Lock est habituellement utilisé pour la synchronisation, il est utilisé sous la forme suivante :

Lock lock = ...; lock.lock(); try{ //处理任务 }catch(Exception ex){ }finally{ lock.unlock(); //释放锁 }
Copier après la connexion

La méthode tryLock() a une valeur de retour, ce qui signifie qu'elle est utilisée pour tenter d'acquérir le verrou si l'acquisition réussit. , il renvoie true , si l'acquisition échoue (c'est-à-dire que le verrou a été acquis par un autre thread), false est renvoyé, ce qui signifie que cette méthode reviendra immédiatement quoi qu'il arrive. Vous n'attendrez pas là-bas si vous ne parvenez pas à obtenir la serrure.

La méthode tryLock(long time, TimeUnit unit) est similaire à la méthode tryLock() La seule différence est que cette méthode attendra un certain temps pendant laquelle elle ne pourra pas obtenir le verrou. obtient le verrou dans le délai imparti. Si le verrou n'est pas atteint, false est renvoyé. Renvoie vrai si le verrou a été obtenu initialement ou pendant la période d'attente.

Donc, dans des circonstances normales, lors de l'acquisition d'un verrou via tryLock, il est utilisé comme ceci :

Lock lock = ...; if(lock.tryLock()) { try{ //处理任务 }catch(Exception ex){ }finally{ lock.unlock(); //释放锁 } }else { //如果不能获取锁,则直接做其他事情 }
Copier après la connexion

la méthode lockInterruptably() est spéciale lors de l'acquisition d'un verrou via cette méthode, si le thread. attend d'acquérir le verrou, ce thread peut répondre aux interruptions, c'est-à-dire interrompre l'état d'attente du thread.

C'est-à-dire que lorsque deux threads veulent acquérir un verrou via lock.lockInterruptible() en même temps, si le thread A acquiert le verrou à ce moment-là et que le thread B attend seulement, alors appelez le threadB sur le thread B La méthode .interrupt() peut interrompre le processus d'attente du thread B.

由于lockInterruptibly()的声明中抛出了异常,所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

因此lockInterruptibly()一般的使用形式如下:

public void method() throws InterruptedException { lock.lockInterruptibly(); try { //..... } finally { lock.unlock(); } }
Copier après la connexion

注意,当一个线程获取了锁之后,是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程,只能中断阻塞过程中的线程。

因此当通过lockInterruptibly()方法获取某个锁时,如果不能获取到,只有进行等待的情况下,是可以响应中断的。

而用synchronized修饰的话,当一个线程处于等待某个锁的状态,是无法被中断的,只有一直等待下去。

2.ReentrantLock

ReentrantLock,意思是“可重入锁”,关于可重入锁的概念在下一节讲述。ReentrantLock是唯一实现了Lock接口的类,并且ReentrantLock提供了更多的方法。下面通过一些实例看具体看一下如何使用ReentrantLock。

例子1,lock()的正确使用方法

public class Test { private ArrayList arrayList = new ArrayList(); public static void main(String[] args) { final Test test = new Test(); new Thread(){ public void run() { test.insert(Thread.currentThread()); }; }.start(); new Thread(){ public void run() { test.insert(Thread.currentThread()); }; }.start(); } public void insert(Thread thread) { Lock lock = new ReentrantLock(); //注意这个地方 lock.lock(); try { System.out.println(thread.getName()+"得到了锁"); for(int i=0;i<5;i++) { arrayList.add(i); } } catch (Exception e) { // TODO: handle exception }finally { System.out.println(thread.getName()+"释放了锁"); lock.unlock(); } } }
Copier après la connexion

输出结果:

Thread-0得到了锁
Thread-1得到了锁
Thread-0释放了锁
Thread-1释放了锁

在insert方法中的lock变量是局部变量,每个线程执行该方法时都会保存一个副本,那么理所当然每个线程执行到lock.lock()处获取的是不同的锁,所以就不会发生冲突。

知道了原因改起来就比较容易了,只需要将lock声明为类的属性即可。

public class Test { private ArrayList arrayList = new ArrayList(); private Lock lock = new ReentrantLock(); //注意这个地方 public static void main(String[] args) { final Test test = new Test(); new Thread(){ public void run() { test.insert(Thread.currentThread()); }; }.start(); new Thread(){ public void run() { test.insert(Thread.currentThread()); }; }.start(); } public void insert(Thread thread) { lock.lock(); try { System.out.println(thread.getName()+"得到了锁"); for(int i=0;i<5;i++) { arrayList.add(i); } } catch (Exception e) { // TODO: handle exception }finally { System.out.println(thread.getName()+"释放了锁"); lock.unlock(); } } }
Copier après la connexion

这样就是正确地使用Lock的方法了。

例子2,tryLock()的使用方法

public class Test { private ArrayList arrayList = new ArrayList(); private Lock lock = new ReentrantLock(); //注意这个地方 public static void main(String[] args) { final Test test = new Test(); new Thread(){ public void run() { test.insert(Thread.currentThread()); }; }.start(); new Thread(){ public void run() { test.insert(Thread.currentThread()); }; }.start(); } public void insert(Thread thread) { if(lock.tryLock()) { try { System.out.println(thread.getName()+"得到了锁"); for(int i=0;i<5;i++) { arrayList.add(i); } } catch (Exception e) { // TODO: handle exception }finally { System.out.println(thread.getName()+"释放了锁"); lock.unlock(); } } else { System.out.println(thread.getName()+"获取锁失败"); } } }
Copier après la connexion

输出结果:

Thread-0得到了锁
Thread-1获取锁失败
Thread-0释放了锁

例子3,lockInterruptibly()响应中断的使用方法:

public class Test { private Lock lock = new ReentrantLock(); public static void main(String[] args) { Test test = new Test(); MyThread thread1 = new MyThread(test); MyThread thread2 = new MyThread(test); thread1.start(); thread2.start(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } thread2.interrupt(); } public void insert(Thread thread) throws InterruptedException{ lock.lockInterruptibly(); //注意,如果需要正确中断等待锁的线程,必须将获取锁放在外面,然后将InterruptedException抛出 try { System.out.println(thread.getName()+"得到了锁"); long startTime = System.currentTimeMillis(); for( ; ;) { if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE) break; //插入数据 } } finally { System.out.println(Thread.currentThread().getName()+"执行finally"); lock.unlock(); System.out.println(thread.getName()+"释放了锁"); } } } class MyThread extends Thread { private Test test = null; public MyThread(Test test) { this.test = test; } @Override public void run() { try { test.insert(Thread.currentThread()); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName()+"被中断"); } } }
Copier après la connexion

运行之后,发现thread2能够被正确中断。

3.ReadWriteLock

ReadWriteLock也是一个接口,在它里面只定义了两个方法:

public interface ReadWriteLock { /** * Returns the lock used for reading. * * @return the lock used for reading. */ Lock readLock(); /** * Returns the lock used for writing. * * @return the lock used for writing. */ Lock writeLock(); }
Copier après la connexion

一个用来获取读锁,一个用来获取写锁。也就是说将文件的读写操作分开,分成2个锁来分配给线程,从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口。

4.ReentrantReadWriteLock

ReentrantReadWriteLock里面提供了很多丰富的方法,不过最主要的有两个方法:readLock()和writeLock()用来获取读锁和写锁。

下面通过几个例子来看一下ReentrantReadWriteLock具体用法。

假如有多个线程要同时进行读操作的话,先看一下synchronized达到的效果:

public class Test { private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); public static void main(String[] args) { final Test test = new Test(); new Thread(){ public void run() { test.get(Thread.currentThread()); }; }.start(); new Thread(){ public void run() { test.get(Thread.currentThread()); }; }.start(); } public synchronized void get(Thread thread) { long start = System.currentTimeMillis(); while(System.currentTimeMillis() - start <= 1) { System.out.println(thread.getName()+"正在进行读操作"); } System.out.println(thread.getName()+"读操作完毕"); } }
Copier après la connexion

这段程序的输出结果会是,直到thread1执行完读操作之后,才会打印thread2执行读操作的信息。

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0读操作完毕

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1读操作完毕

而改成用读写锁的话:

public class Test { private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); public static void main(String[] args) { final Test test = new Test(); new Thread(){ public void run() { test.get(Thread.currentThread()); }; }.start(); new Thread(){ public void run() { test.get(Thread.currentThread()); }; }.start(); } public void get(Thread thread) { rwl.readLock().lock(); try { long start = System.currentTimeMillis(); while(System.currentTimeMillis() - start <= 1) { System.out.println(thread.getName()+"正在进行读操作"); } System.out.println(thread.getName()+"读操作完毕"); } finally { rwl.readLock().unlock(); } } }
Copier après la connexion

此时打印的结果为:

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-0正在进行读操作

Thread-1正在进行读操作

Thread-0读操作完毕

Thread-1读操作完毕

说明thread1和thread2在同时进行读操作。

这样就大大提升了读操作的效率。

不过要注意的是,如果有一个线程已经占用了读锁,则此时其他线程如果要申请写锁,则申请写锁的线程会一直等待释放读锁。

如果有一个线程已经占用了写锁,则此时其他线程如果申请写锁或者读锁,则申请的线程会一直等待释放写锁。

关于ReentrantReadWriteLock类中的其他方法感兴趣的朋友可以自行查阅API文档。

5.Lock和synchronized的选择

总结来说,Lock和synchronized有以下几点不同:

1)Lock是一个接口,而synchronized是Java中的关键字,synchronized是内置的语言实现;

2)synchronized在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象发生;而Lock在发生异常时,如果没有主动通过unLock()去释放锁,则很可能造成死锁现象,因此使用Lock时需要在finally块中释放锁;

3)Lock可以让等待锁的线程响应中断,而synchronized却不行,使用synchronized时,等待的线程会一直等待下去,不能够响应中断;

4)通过Lock可以知道有没有成功获取锁,而synchronized却无法办到。

5)Lock可以提高多个线程进行读操作的效率。

在性能上来说,如果竞争资源不激烈,两者的性能是差不多的,而当竞争资源非常激烈时(即有大量线程同时竞争),此时Lock的性能要远远优于synchronized。所以说,在具体使用时要根据适当情况选择。

三.锁的相关概念介绍

在前面介绍了Lock的基本使用,这一节来介绍一下与锁相关的几个概念。

1.可重入锁

如果锁具备可重入性,则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁,可重入性在我看来实际上表明了锁的分配机制:基于线程的分配,而不是基于方法调用的分配。举个简单的例子,当一个线程执行到某个synchronized方法时,比如说method1,而在method1中会调用另外一个synchronized方法method2,此时线程不必重新去申请锁,而是可以直接执行方法method2。

看下面这段代码就明白了:

class MyClass { public synchronized void method1() { method2(); } public synchronized void method2() { } }
Copier après la connexion

上述代码中的两个方法method1和method2都用synchronized修饰了,假如某一时刻,线程A执行到了method1,此时线程A获取了这个对象的锁,而由于method2也是synchronized方法,假如synchronized不具备可重入性,此时线程A需要重新申请锁。但是这就会造成一个问题,因为线程A已经持有了该对象的锁,而又在申请获取该对象的锁,这样就会线程A一直等待永远不会获取到的锁。

而由于synchronized和Lock都具备可重入性,所以不会发生上述现象。

2.可中断锁

可中断锁:顾名思义,就是可以相应中断的锁。

在Java中,synchronized就不是可中断锁,而Lock是可中断锁。

如果某一线程A正在执行锁中的代码,另一线程B正在等待获取该锁,可能由于等待时间过长,线程B不想等待了,想先处理其他事情,我们可以让它中断自己或者在别的线程中中断它,这种就是可中断锁。

在前面演示lockInterruptibly()的用法时已经体现了Lock的可中断性。

3.公平锁

公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁,当这个锁被释放时,等待时间最久的线程(最先请求的线程)会获得该所,这种就是公平锁。

非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

在Java中,synchronized就是非公平锁,它无法保证等待的线程获取锁的顺序。

而对于ReentrantLock和ReentrantReadWriteLock,它默认情况下是非公平锁,但是可以设置为公平锁。

看一下这2个类的源代码就清楚了:

Explication détaillée de la programmation simultanée Java

在ReentrantLock中定义了2个静态内部类,一个是NotFairSync,一个是FairSync,分别用来实现非公平锁和公平锁。

我们可以在创建ReentrantLock对象时,通过以下方式来设置锁的公平性:

ReentrantLock lock = new ReentrantLock(true);
Copier après la connexion

如果参数为true表示为公平锁,为fasle为非公平锁。默认情况下,如果使用无参构造器,则是非公平锁。

Explication détaillée de la programmation simultanée Java

另外在ReentrantLock类中定义了很多方法,比如:

isFair() //判断锁是否是公平锁

isLocked() //判断锁是否被任何线程获取了

isHeldByCurrentThread() //判断锁是否被当前线程获取了

hasQueuedThreads() //判断是否有线程在等待该锁

在ReentrantReadWriteLock中也有类似的方法,同样也可以设置为公平锁和非公平锁。不过要记住,ReentrantReadWriteLock并未实现Lock接口,它实现的是ReadWriteLock接口。

4.读写锁

读写锁将对一个资源(比如文件)的访问分成了2个锁,一个读锁和一个写锁。

正因为有了读写锁,才使得多个线程之间的读操作不会发生冲突。

ReadWriteLock就是读写锁,它是一个接口,ReentrantReadWriteLock实现了这个接口。

可以通过readLock()获取读锁,通过writeLock()获取写锁。

上面已经演示过了读写锁的使用方法,在此不再赘述。

原文地址:http://www.cnblogs.com/dolphin0520/p/3923167.html

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Étiquettes associées:
source:cnblogs.com
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal
À propos de nous Clause de non-responsabilité Sitemap
Site Web PHP chinois:Formation PHP en ligne sur le bien-être public,Aidez les apprenants PHP à grandir rapidement!