1. 程式人生 > >synchronized(this)與synchronized(class) 簡單例項

synchronized(this)與synchronized(class) 簡單例項

通過對以上文章的拜讀,我進一步加深了對執行緒同步鎖的理解。

下面就根據自己的理解,進行的簡單例項操作演示。

在看下面的程式碼前,強烈建議先拜讀上面的文章。

MainActivity.java

package com.snowdream.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends Activity {

	private static final int MSG_CLEAR = 0;
	private static final int MSG_UPDATE = 1;

	private final Object mObject = new Object();
	private final String tag = "MainActivity";
	ExecutorService pool = null; 

	private static TextView mTextView = null;

	private static Handler mHandler = new Handler(){
		public void handleMessage(Message msg){
			switch (msg.what) {
			case MSG_CLEAR:
				mTextView.setText("");
				break;
			case MSG_UPDATE:
				String str = (String)msg.obj;
				if (!TextUtils.isEmpty(str)) {
					mTextView.append(str);
					mTextView.append("\n");
				}
				break;
			default:
				break;
			}
		};
	};


	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		initView();
		initData();
	}


	private void initView() {
		mTextView = (TextView)findViewById(R.id.textView1);
	}

	private void initData() {
		pool = Executors.newFixedThreadPool(2); 
	}


	@Override
	protected void onDestroy() {
		super.onDestroy();
		pool.shutdown();
	}

	public void OnButton1Click(View view) {
		int id = view.getId();
		switch (id) {
		case R.id.button1:
			//synchronized(class)
			//synchronized(this)
			mHandler.sendMessage(mHandler.obtainMessage(MSG_CLEAR));
			
			Sync1_Class sync1_Class = new Sync1_Class();
			Sync1_Object sync1_Object = new Sync1_Object();
			pool.execute(sync1_Class);
			pool.execute(sync1_Object);
			break;
		case R.id.button2:
			//synchronized(this)
			//synchronized(this)
			mHandler.sendMessage(mHandler.obtainMessage(MSG_CLEAR));
			
			Sync2_Object_1  sync2_Object_1 = new Sync2_Object_1();
			Sync2_Object_2 sync2_Object_2 = new Sync2_Object_2();
			pool.execute(sync2_Object_1);
			pool.execute(sync2_Object_2);	
			break;
		case R.id.button3:
			//synchronized(class)
			//synchronized(class)
			mHandler.sendMessage(mHandler.obtainMessage(MSG_CLEAR));

			Sync3_Class_1 sync3_Class_1 = new Sync3_Class_1();
			Sync3_Class_2 sync3_Class_2 = new Sync3_Class_2();
			pool.execute(sync3_Class_1);
			pool.execute(sync3_Class_2);
			break;
		default:
			break;
		}
	}

	public class Sync1_Class implements Runnable {
		public void run() {
			synchronized(MainActivity.class){
				for (int i = 0; i < 100; i++) {
					Log.i(tag, "Sync1_Class: "+ i);
					
					mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE, "Sync1_Class: "+ i));
				}
			}	
		}
	} 


	public class Sync1_Object implements Runnable {
		public void run() {
			synchronized(mObject){
				for (int i = 0; i < 100; i++) {
					Log.i(tag, "Sync1_Object: "+ i);
					
					mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE,  "Sync1_Object: "+ i));
				}
			}
		}
	} 



	public class Sync2_Object_1 implements Runnable {
		public void run() {
			synchronized(mObject){
				for (int i = 0; i < 100; i++) {
					Log.i(tag, "Sync2_Object_1: "+ i);
					
					mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE,  "Sync2_Object_1: "+ i));
				}
			}
		}
	} 


	public class Sync2_Object_2 implements Runnable {
		public void run() {
			synchronized(mObject){
				for (int i = 0; i < 100; i++) {
					Log.i(tag, "Sync2_Object_2: "+ i);
					
					mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE,  "Sync2_Object_2: "+ i));
				}
			}
		}
	} 


	public class Sync3_Class_1 implements Runnable {
		public void run() {
			synchronized(MainActivity.class){
				for (int i = 0; i < 100; i++) {
					Log.i(tag, "Sync3_Class_1: "+ i);
					
					mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE,  "Sync3_Class_1: "+ i));
				}
			}
		}
	} 


	public class Sync3_Class_2 implements Runnable {
		public void run() {
			synchronized(MainActivity.class){
				for (int i = 0; i < 100; i++) {
					Log.i(tag, "Sync3_Class_2: "+ i);
					
					mHandler.sendMessage(mHandler.obtainMessage(MSG_UPDATE,  "Sync3_Class_2: "+ i));
				}
			}
		}
	} 

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		getMenuInflater().inflate(R.menu.activity_main, menu);
		return true;
	}
}


activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <LinearLayout
        android:id="@+id/linearLayout1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true" >

        <Button
            android:id="@+id/button1"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:onClick="OnButton1Click"
            android:text="Button1" />

        <Button
            android:id="@+id/button2"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:onClick="OnButton1Click"
            android:text="Button2" />

        <Button
            android:id="@+id/button3"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:gravity="center"
            android:onClick="OnButton1Click"
            android:text="Button3" />
    </LinearLayout>

    <ScrollView
        android:id="@+id/scrollView1"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_below="@+id/linearLayout1"
        android:layout_toLeftOf="@+id/textView1" >

        <TextView
            android:id="@+id/textView1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:padding="@dimen/padding_small"
            android:text="Loading..."
            tools:context=".MainActivity" />
    </ScrollView>

</RelativeLayout>

效果預覽:


歡迎大家關注我的微信公眾號:

微信公眾號:sn0wdr1am


相關推薦

synchronized(this)synchronized(class) 簡單例項

通過對以上文章的拜讀,我進一步加深了對執行緒同步鎖的理解。 下面就根據自己的理解,進行的簡單例項操作演示。 在看下面的程式碼前,強烈建議先拜讀上面的文章。 MainActivity.java package com.snowdream.demo; import

synchronized(this) synchronized(class) 理解

moni 獲取 interrupt locking volatil block ++ link ted 1.概念 synchronized 是 Java 中的關鍵字,是利用鎖的機制來實現同步的。 鎖機制有如下兩種特性: 互斥性:即在同一時間只允許一個線程持有某個

synchronized(this)、synchronized(class)synchronized(Object)的區別

在多執行緒開發中,我們經常看到synchronized(this)、synchronized(*.class)與synchronized(任意物件)這幾種型別同步方法。但是是否知道這幾種寫法有什麼區別

synchronized(this/object/類.class)的區別

synchronized this object Class的區別 首先放上結論: 1.this:相當於只有一把鑰匙的多把鎖,他可以鎖住多個程式碼塊,但是每次開鎖只能一個,如果鑰匙在其他程式碼塊手上,那麼新來的被鎖的多個程式碼塊就拿不到鑰匙,進不了方自己的程式碼塊 2.objec

16、靜態同步synchronized方法synchronized(class)程式碼塊

靜態同步synchronized方法 package com.demo19; public class MyObject { synchronized public static void a(){ try { System.out.prin

機器學習案例——梯度下降邏輯迴歸簡單例項

梯度下降例項     下圖是f(x) = x2+3x+4 的函式影象,這是初中的一元二次函式,它的導數為g(x) = f’(x) = 2x+3。我們很明確的知道,當x = -1.5時,函式取得最小值。     下面就通過梯度下降法來計算函式取最小值時x的

synchronized(this)和synchronized(object)的理解

如果有一塊程式碼(或方法)可能被多個執行緒同時訪問,然後裡面操作的資料修改操作可能因為不同執行緒的操作而不一致的時候,使用synchronized鎖定這塊程式碼,確保同時只有一個執行緒訪問這個程式碼塊。也就是說,關鍵字synchronized可以用在任何類的方法裡面,即使該類

執行緒-synchronized方法和同步塊的作用範圍;synchronized(this)和synchronized(obj)的區別

原文:http://m.blog.csdn.net/blog/u010802573/38661719 參考資源: http://www.cnblogs.com/oracleDBA/archive/2010/05/22/1741642.html http://www

synchronized(this)和synchronized(object)區別

synchronized 關鍵字,它包括兩種用法:synchronized 方法和 synchronized 塊。 1. synchronized 方法:通過在方法宣告中加入 synchronized關鍵字來宣告 synchronized 方法。如: public syn

四、JAVA多執行緒:執行緒安全資料同步 (synchronizedThis Monitor、Class Monitor)

      本章首先從一個簡單的例子入手,講解了資料同步的概念,以及會引發資料不一致性問題的情況,然後非常詳細地介紹了synchronized關鍵字以及與其對應的JVM指令。本章的最後還分析了幾種可能引起程式進入死鎖的原因,以及如何使用工具進行診斷,執行緒安全與資料同步

synchronized(.class) synchronized(Object ) synchronized(this) 區別

1. synchronized(.class)只要是訪問這個類的方法,就會同步,不管用這個類建立了幾個物件!一般單列模式常用例如:private static volatile SingIn instance=null; private SingIn (){ } p

[原創][MethodImpl(MethodImplOptions.Synchronized)]、lock(this)lock(typeof(...))

對於稍微有點經驗的.NET開發人員來說,倘若被問及如何保持執行緒同步,我想很多人都能說好好幾種。在眾多的執行緒同步的可選方式中,加鎖無疑是最為常用的。如果僅僅是基於方法級別的執行緒同步,使用System.Runtime.CompilerServices.MethodI

JAVA多線程之volatile synchronized 的比較

@override effect process 棧空間 完成 內存可見性 沒有 hash 主從 一,volatile關鍵字的可見性 要想理解volatile關鍵字,得先了解下JAVA的內存模型,Java內存模型的抽象示意圖如下: 從圖中可以看出: ①每個線程都有一個自己的

java的多線程安全,ReentrantLocksynchronized

深入 print 改變 pri 誤區 不起作用 全局 直接 div 前言 多線程總的來說是一個很大的模塊,所以雖然之前就想寫但一直感覺有地方沒有理解透,在經過了一段時間學習後,終於有點感覺了,在此寫下隨筆。 多線程安全問題##: 首先和大家討論一下多線程為什麽會不安全,大

synchronized理解總結

public mar 環境 new t 觀察 初始 down ble () synchronized理解與總結 第一次實現的代碼分析(不一定哪個線程搶到任務,搶到的線程會一直把任務執行完,不給其它線程機會) 環境模擬:假設車站的車票開放給三個票販子賣 class MyTh

ReentrantLocksynchronized

操作 pan 決定 變量 HR 功能 編碼 運行 部分 相同:ReentrantLock提供了synchronized類似的功能和內存語義。 不同: 1.ReentrantLock功能性方面更全面,比如時間鎖等候,可中斷鎖等候,鎖投票等,因此更有擴展性。在多個條件變量和高

volatilesynchronized有什麽區別?

當前 使用 ros zed ati size run方法 優化 VM 下列說法正確的是()?   A.我們直接調用Thread對象的run方法會報異常,所以我們應該使用start方法來開啟一個線程   B.一個進程是一個獨立的運行環境,可以被看做一個程序或者一個應用。而線程

【並發編程】CASsynchronized

ews 算法 正式 ima PE 理解 cnblogs inf sch 線程安全 眾所周知,Java是多線程的。但是,Java對多線程的支持其實是一把雙刃劍。一旦涉及到多個線程操作共享資源的情況時,處理不好就可能產生線程安全問題。線程安全性可能是非常復雜的,在沒有充足的同步

Java多執行緒學習筆記(六) synchronized(this)同步語句塊

synchronized (this)同步語句塊 1. 一半非同步,一半同步 1.1 Task 1.2 ThreadA 1.3 ThreadB 1.4 Test 1.5 執行結果 2. synchronize