溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
Java中使用volatile關鍵字怎么實現多線程，很多新手對此不是很清楚，為了幫助大家解決這個難題，下面小編將為大家詳細講解，有這方面需求的人可以來學習下，希望你能有所收獲。
volatile
volatile是一種輕量同步機制。請看例子
MyThread25類
public class MyThread25 extends Thread{
private boolean isRunning = true;
public boolean isRunning()
{
return isRunning;
}
public void setRunning(boolean isRunning)
{
this.isRunning = isRunning;
}
public void run()
{
System.out.println("進入run了");
while (isRunning == true){}
System.out.println("線程被停止了");
}
public static void main(String[] args) throws InterruptedException {
MyThread25 mt = new MyThread25();
mt.start();
Thread.sleep(1000);
mt.setRunning(false);
System.out.println("已設置為false");
}
}輸出結果如下
進入run了 已設置為false
為什么程序始終不結束？說明mt.setRunning(false);沒有起作用。
這里我們說下Java內存模型（JMM）
java虛擬機有自己的內存模型（Java Memory Model，JMM），JMM可以屏蔽掉各種硬件和操作系統的內存訪問差異，以實現讓java程序在各種平臺下都能達到一致的內存訪問效果。
JMM定義了線程和主內存之間的抽象關系：共享變量存儲在主內存(Main Memory)中，每個線程都有一個私有的本地內存（Local Memory），本地內存保存了被該線程使用到的主內存的副本，線程對變量的所有操作都必須在本地內存中進行，而不能直接讀寫主內存中的變量。這三者之間的交互關系如下
出現上述運行結果的原因是，主內存isRunning = true， mt.setRunning(false)設置主內存isRunning = false，本地內存中isRunning仍然是true，線程用的是本地內存，所以進入了死循環。
在isRunning前加上volatile
private volatile boolean isRunning = true;
輸出結果如下
進入run了 已設置為false 線程被停止了
volatile不能保證原子類線程安全
先看例子
MyThread26_0類，用volatile修飾num
public class MyThread26_0 extends Thread {
public static volatile int num = 0;
//使用CountDownLatch來等待計算線程執行完
static CountDownLatch countDownLatch = new CountDownLatch(30);
@Override
public void run() {
for(int j=0;j<1000;j++){
num++;//自加操作
}
countDownLatch.countDown();
}
public static void main(String[] args) throws InterruptedException {
MyThread26_0[] mt = new MyThread26_0[30];
//開啟30個線程進行累加操作
for(int i=0;i<mt.length;i++){
mt[i] = new MyThread26_0();
}
for(int i=0;i<mt.length;i++){
mt[i].start();
}
//等待計算線程執行完
countDownLatch.await();
System.out.println(num);
}
}輸出結果如下
25886
理論上，應該輸出30000。原子操作表示一段操作是不可分割的，因為num++不是原子操作，這樣會出現線程對過期的num進行自增，此時其他線程已經對num進行了自增。
num++分三步：讀取、加一、賦值。
結論：
volatile只會對單個的的變量讀寫具有原子性，像num++這種復合操作volatile是無法保證其原子性的
解決方法：
用原子類AtomicInteger的incrementAndGet方法自增
public class MyThread26_1 extends Thread {
//使用原子操作類
public static AtomicInteger num = new AtomicInteger(0);
//使用CountDownLatch來等待計算線程執行完
static CountDownLatch countDownLatch = new CountDownLatch(30);
@Override
public void run() {
for(int j=0;j<1000;j++){
num.incrementAndGet();//原子性的num++,通過循環CAS方式
}
countDownLatch.countDown();
}
public static void main(String []args) throws InterruptedException {
MyThread26_1[] mt = new MyThread26_1[30];
//開啟30個線程進行累加操作
for(int i=0;i<mt.length;i++){
mt[i] = new MyThread26_1();
}
for(int i=0;i<mt.length;i++){
mt[i].start();
}
//等待計算線程執行完
countDownLatch.await();
System.out.println(num);
}
}輸出結果如下
30000
原子類方法組合使用線程不安全
例子如下
ThreadDomain27類
public class ThreadDomain27 {
public static AtomicInteger aiRef = new AtomicInteger();
public void addNum()
{
System.out.println(Thread.currentThread().getName() + "加了100之后的結果：" + aiRef.addAndGet(100));
aiRef.getAndAdd(1);
}
}MyThread27類
public class MyThread27 extends Thread{
private ThreadDomain27 td;
public MyThread27(ThreadDomain27 td)
{
this.td = td;
}
public void run()
{
td.addNum();
}
public static void main(String[] args)
{
try
{
ThreadDomain27 td = new ThreadDomain27();
MyThread27[] mt = new MyThread27[5];
for (int i = 0; i < mt.length; i++)
{
mt[i] = new MyThread27(td);
}
for (int i = 0; i < mt.length; i++)
{
mt[i].start();
}
Thread.sleep(1000);
System.out.println(ThreadDomain27.aiRef.get());
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}輸出結果如下
Thread-2加了100之后的結果：100 Thread-3加了100之后的結果：200 Thread-0加了100之后的結果：302 Thread-1加了100之后的結果：403 Thread-4加了100之后的結果：504 505
理想的輸出結果是100，201，302...，因為addAndGet方法和getAndAdd方法構成的addNum不是原子操作。
解決該問題只需要在addNum加上synchronized關鍵字。
輸出結果如下
Thread-1加了100之后的結果：100 Thread-0加了100之后的結果：201 Thread-2加了100之后的結果：302 Thread-3加了100之后的結果：403 Thread-4加了100之后的結果：504 505
結論：
volatile解決的是變量在多個線程之間的可見性，但是無法保證原子性。
synchronized不僅保障了原子性外，也保障了可見性。
volatile和synchronized比較
先看實例，使用volatile是什么效果
CountDownLatch保證10個線程都能執行完成，當然你也可以在System.out.println(test.inc);之前使用Thread.sleep(xxx)
public class MyThread28 {
//使用CountDownLatch來等待計算線程執行完
static CountDownLatch countDownLatch = new CountDownLatch(10);
public volatile int inc = 0;
public void increase() {
inc++;
}
public static synchronized void main(String[] args) throws InterruptedException {
final MyThread28 test = new MyThread28();
for(int i=0;i<10;i++){
new Thread(){
public void run() {
for(int j=0;j<1000;j++)
test.increase();
countDownLatch.countDown();
}
}.start();
}
countDownLatch.await();
System.out.println(test.inc);
}
}運行結果如下
9677
每次運行結果都不一致。剛才我已經解釋過，這里我再解釋一遍。
使用volatile修飾int型變量i，多個線程同時進行i++操作。比如有兩個線程A和B對volatile修飾的i進行i++操作，i的初始值是0，A線程執行i++時從本地內存剛讀取了i的值0（i++不是原子操作），就切換到B線程了，B線程從本地內存中讀取i的值也為0，然后就切換到A線程繼續執行i++操作，完成后i就為1了，接著切換到B線程，因為之前已經讀取過了，所以繼續執行i++操作，最后的結果i就為1了。同理可以解釋為什么每次運行結果都是小于10000的數字。
解決方法：
使用synchronized關鍵字
public class MyThread28 {
//使用CountDownLatch來等待計算線程執行完
static CountDownLatch countDownLatch = new CountDownLatch(10);
public int inc = 0;
public synchronized void increase() {
inc++;
}
public static synchronized void main(String[] args) throws InterruptedException {
final MyThread28 test = new MyThread28();
for(int i=0;i<10;i++){
new Thread(){
public void run() {
for(int j=0;j<1000;j++)
test.increase();
countDownLatch.countDown();
}
}.start();
}
countDownLatch.await();
System.out.println(test.inc);
}
}輸出結果如下
10000
synchronized不管是否是原子操作，它能保證同一時刻只有一個線程獲取鎖執行同步代碼，會阻塞其他線程。
結論：
volatile只能用在變量，synchronized可以在變量、方法上使用。
volatile不會造成線程阻塞，synchronized會造成線程阻塞。
volatile效率比synchronized高。
看完上述內容是否對您有幫助呢？如果還想對相關知識有進一步的了解或閱讀更多相關文章，請關注億速云行業資訊頻道，感謝您對億速云的支持。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
