2. 程式人生 > >從頭認識多執行緒-2.22 內部類的同步機制跟普通類相同

從頭認識多執行緒-2.22 內部類的同步機制跟普通類相同

阿新 • • 發佈：2018-12-26

這一章節主要討論內部類的同步機制跟普通類相同。

1.當同步方法的時候

package com.ray.deepintothread.ch02.topic_22;

/**
 * 
 * @author RayLee
 *
 */
public class SynchOfInnerClass {
	class InnerClass {
		private int id = 0;

		public synchronized void service_1() throws InterruptedException {
			for (int i = 0; i < 5; i++) {
				System.out.println(Thread.currentThread().getName() + " id:" + id++);
				Thread.sleep(50);
			}
		}

		public synchronized void service_2() throws InterruptedException {
			for (int i = 0; i < 5; i++) {
				System.out.println(Thread.currentThread().getName() + " id:" + id++);
				Thread.sleep(100);
			}
		}
	}

	public InnerClass getInnerClass() {
		return new InnerClass();
	}

	public static void main(String[] args) {
		SynchOfInnerClass synchOfInnerClass = new SynchOfInnerClass();
		InnerClass innerClass = synchOfInnerClass.getInnerClass();
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					innerClass.service_1();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread.start();
		Thread thread2 = new Thread(new Runnable() {
			public void run() {
				try {
					innerClass.service_2();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread2.start();
	}
}

輸出：

Thread-0 id:0
Thread-0 id:1
Thread-0 id:2
Thread-0 id:3
Thread-0 id:4
Thread-1 id:5
Thread-1 id:6
Thread-1 id:7
Thread-1 id:8
Thread-1 id:9

2.當同步程式碼塊的時候

package com.ray.deepintothread.ch02.topic_22;

/**
 * 
 * @author RayLee
 *
 */
public class SynchOfInnerClass2 {
	class InnerClass {
		private int id = 0;
		private Object object = new Object();

		public void service_1() throws InterruptedException {
			synchronized (object) {
				for (int i = 0; i < 5; i++) {
					System.out.println(Thread.currentThread().getName() + " id:" + id++);
					Thread.sleep(50);
				}
			}
		}

		public void service_2() throws InterruptedException {
			synchronized (object) {
				for (int i = 0; i < 5; i++) {
					System.out.println(Thread.currentThread().getName() + " id:" + id++);
					Thread.sleep(100);
				}
			}
		}
	}

	public InnerClass getInnerClass() {
		return new InnerClass();
	}

	public static void main(String[] args) {
		SynchOfInnerClass2 synchOfInnerClass = new SynchOfInnerClass2();
		InnerClass innerClass = synchOfInnerClass.getInnerClass();
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					innerClass.service_1();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread.start();
		Thread thread2 = new Thread(new Runnable() {
			public void run() {
				try {
					innerClass.service_2();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread2.start();
	}
}

輸出：

Thread-0 id:0
Thread-0 id:1
Thread-0 id:2
Thread-0 id:3
Thread-0 id:4
Thread-1 id:5
Thread-1 id:6
Thread-1 id:7
Thread-1 id:8
Thread-1 id:9

上面的兩種方式都是可以實現同步機制，使得資料保持一致，不會出現髒讀

3.當同步方法與同步程式碼塊同時出現的時候

package com.ray.deepintothread.ch02.topic_22;

/**
 * 
 * @author RayLee
 *
 */
public class SynchOfInnerClass3 {
	class InnerClass {
		private int id = 0;
		private Object object = new Object();

		public void service_1() throws InterruptedException {
			synchronized (object) {
				for (int i = 0; i < 5; i++) {
					System.out.println(Thread.currentThread().getName() + " id:" + id++);
					Thread.sleep(50);
				}
			}
		}

		public synchronized void service_2() throws InterruptedException {
			for (int i = 0; i < 5; i++) {
				System.out.println(Thread.currentThread().getName() + " id:" + id++);
				Thread.sleep(100);
			}
		}
	}

	public InnerClass getInnerClass() {
		return new InnerClass();
	}

	public static void main(String[] args) {
		SynchOfInnerClass3 synchOfInnerClass = new SynchOfInnerClass3();
		InnerClass innerClass = synchOfInnerClass.getInnerClass();
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					innerClass.service_1();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread.start();
		Thread thread2 = new Thread(new Runnable() {
			public void run() {
				try {
					innerClass.service_2();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread2.start();
	}
}

輸出：

Thread-0 id:0
Thread-1 id:1
Thread-0 id:2
Thread-1 id:3
Thread-0 id:4
Thread-0 id:5
Thread-0 id:6
Thread-1 id:6
Thread-1 id:7
Thread-1 id:8

從輸出可以看見，資料不同步，出現髒讀

4.當使用不同監視器來同步程式碼塊的時候

package com.ray.deepintothread.ch02.topic_22;

/**
 * 
 * @author RayLee
 *
 */
public class SynchOfInnerClass4 {
	class InnerClass {
		private int id = 0;
		private Object object1 = new Object();
		private Object object2 = new Object();

		public void service_1() throws InterruptedException {
			synchronized (object1) {
				for (int i = 0; i < 5; i++) {
					System.out.println(Thread.currentThread().getName() + " id:" + id++);
					Thread.sleep(50);
				}
			}
		}

		public synchronized void service_2() throws InterruptedException {
			synchronized (object2) {
				for (int i = 0; i < 5; i++) {
					System.out.println(Thread.currentThread().getName() + " id:" + id++);
					Thread.sleep(100);
				}
			}
		}
	}

	public InnerClass getInnerClass() {
		return new InnerClass();
	}

	public static void main(String[] args) {
		SynchOfInnerClass4 synchOfInnerClass = new SynchOfInnerClass4();
		InnerClass innerClass = synchOfInnerClass.getInnerClass();
		Thread thread = new Thread(new Runnable() {
			public void run() {
				try {
					innerClass.service_1();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread.start();
		Thread thread2 = new Thread(new Runnable() {
			public void run() {
				try {
					innerClass.service_2();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		thread2.start();
	}
}

輸出：

Thread-0 id:0
Thread-1 id:1
Thread-0 id:2
Thread-1 id:3
Thread-0 id:3
Thread-0 id:4
Thread-0 id:5
Thread-1 id:5
Thread-1 id:6
Thread-1 id:7

上面的兩種情況就會出現資料不同步的現象。

總結：這一章節主要展示內部類的同步機制跟普通類相同。

這一章節就到這裡，謝謝

------------------------------------------------------------------------------------


相關推薦

從頭認識多執行緒-2.22 內部類的同步機制跟普通類相同

這一章節主要討論內部類的同步機制跟普通類相同。1.當同步方法的時候package com.ray.deepintothread.ch02.topic_22; /** * * @author RayLee * */ public class SynchOfInner

多執行緒和匿名內部類的理解

多執行緒 一.多執行緒 好處:提高任務的執行效率 (執行緒本身也會耗費系統資源 建立執行緒要把握度) 程序:一個正在執行的程式 一個程序可以有一個或多個執行緒 分時排程:cpu同

多執行緒Runnable匿名內部類一定要注意大坑

通常情況下，當需要模擬多執行緒的時候我們會選擇兩種方式。第一種就是自己實現Runnable類，然後在主類中呼叫我們自己實現的Runnable，例如： package concurrent; public class MyRunnable implements Runnab

java 多執行緒 之匿名內部類實現多執行緒

package 匿名內部類實現多執行緒; public class Demo { public static void main(String[] args) { // 繼承Thread類實現多執行緒 new Thread() {

Java進階(四十二)Java中多執行緒使用匿名內部類的方式進行建立3種方式

Java中多執行緒使用匿名內部類的方式進行建立3種方式 package cn.edu.ujn.demo; // 匿名內部類的格式： public class ThreadDemo {

執行緒(2)--匿名內部類實現執行緒的兩種方式

package com.fenqing.duoxiancheng; public class d3_thread { public static void main(String[] arg

再說說單例模式和多執行緒（靜態內部類實現）

靜態內部類： package thread.singleton; public class StaticInnerClassSingleton { private static class Singleton{ private static Singleton si

java 多執行緒 資料流 內部類（播放音樂）

一.多執行緒 1.程序與執行緒 程序：負責資源管理（記憶體） 執行緒：負責的程式的執行 2.類實現 a、定義一個類，繼承Thread b、重寫Run方法 c、啟動執行緒（執行緒物件.start()

[java多執行緒]關於Java和Scala同步機制你不知道的5個真相

實際上，所有的伺服器應用在多執行緒中都需要某種型別的同步機制。框架已經為我們做了大多數的同步的工作，這些框架包括web伺服器、資料庫連線客戶端、訊息框架等。我們可以通過Java和Scala提供的多種元件來寫出可靠的多執行緒應用。這些元件包括，物件池、併發集合類、高階鎖、執

Java多執行緒2.9.實現執行緒的常用方式-匿名內部類

實現執行緒的常用方式-匿名內部類 1、匿名內部類的格式 匿名內部類的格式。 本質：是該類或者介面的子類物件。 new 類名或者介面名() { 重寫方法; }; 2、實現執行緒的常用

多執行緒2-synchronized、lock

1、什麼時候會出現執行緒安全問題？ 　　在多執行緒程式設計中，可能出現多個執行緒同時訪問同一個資源，可以是：變數、物件、檔案、資料庫表等。此時就存在一個問題： 　　每個執行緒執行過程是不可控的，可能導致最終結果與實際期望結果不一致或者直接導致程式出錯。 　　如我們在第一篇部落格中出現的count--的問

java多執行緒2.執行緒安全之可見性

要編寫正確的併發程式，關鍵在於：在訪問共享的可變狀態時需要進行正確的管理 可見性： 同步的另一個重要目的——記憶體可見性。 我們不僅希望防止某個執行緒正在使用物件狀態而另一個執行緒同時在修改狀態，而且希望當一個執行緒修改了物件狀態後，其他執行緒能夠看到發生的狀態變化（互斥訪問/通訊效果

python多執行緒獲取區域網內所有電腦IP

#coding = utf-8 import os,os.path import threading import time lock = threading.RLock() def action(ip): result = "ip.txt" return1 = os.sy

python多執行緒———2、建立多執行緒的兩種方式

 法一、使用Thread類例項化 法二、繼承Thread來實現多執行緒 #對於io操作來說，多執行緒和多程序效能差別不大 #1、使用Thread類例項化 import time import threading def get_detail_html(url): prin

23（多執行緒2）

1 休眠執行緒 2 守護執行緒 這個概念需要解釋一下，以象棋為例，非守護執行緒相當於帥，守護執行緒相當於車馬相士，當帥都沒了，車馬相士就失去了它的意義了，就是非守護執行緒停止了，守護執行緒也就gg了。 結果就是aaaa不會輸出50次了。 3 加入執行緒（插隊執行緒）

Java多執行緒2.1.多執行緒之死鎖

多執行緒之死鎖 1、鎖物件Lock 雖然我們可以理解同步程式碼塊和同步方法的鎖物件問題，但是我們並沒有直接看到在哪裡加上了鎖，在哪裡釋放了鎖。 為了更清晰的表達如何加鎖和釋放鎖，JDK5以後提

Java多執行緒2.2.執行緒間通訊

執行緒間通訊問題 1、執行緒間通訊問題 （1）執行緒間通訊問題：不同種類的執行緒之間針對同一個資源的操作。 （2）通過設定執行緒(生產者)和獲取執行緒(消費者)針對同一個學生物件進行操作。 2、執行緒間通訊舉例 （1）建立學生類 package cn.itca

Java多執行緒2.4.生產者與消費者之間的關係3

生產者與消費者之間的關係 1、執行緒間通訊舉例的問題解決2 （1）建立學生類 package cn.itcast_05; public class Student { String name; int age; boolean flag; // 預設情況是沒有

Java多執行緒2.6.執行緒組的概述與使用

執行緒組的概述與使用 1、執行緒組 執行緒組： 把多個執行緒組合到一起。 主要作用： 它可以對一批執行緒進行分類管理，Java允許程式直接對執行緒組進行控制。 （1）建立執行緒類 packa

Java多執行緒2.8.執行緒池2

執行緒池 1、實現Callable介面來實現執行緒池 Callable：是帶泛型的介面。 這裡指定的泛型其實是call()方法的返回值型別。 （1）建立實現Callable類的執行緒類 pa