Java线程(一)

        线程同步：synchronized方法和synchronized代码块
        一个synchronized方法在它执行前得到一个监视器锁。

        (1).对于类方法(static方法)，使用与该方法的类的类对象相关联的锁。

        (2).对于实例方法，使用与this(为之调用该方法的对象)相关联的锁。

        (3).synchronized代码块对各对象使用同样的锁。

1.同步方法
	public synchronized void accessMethod(){}

2.同步代码块
	synchronized(syncObject) {
		//允许访问控制的代码
	}

       无论是同步方法还是同步代码块，两者之间并没有本质的区别，关键是我们能否正确的理解当前所使用的锁。  

       浅谈synchronized应用于实例方法和对象之上

       对于实例方法，synchronized 锁定的是对象(objects)而非方法(methods)或代码(code)，每个对象只有一个lock(锁)与之相关联。

       当synchronized 被当作方法修饰符的时候，它所取得的lock 将被交给函数调用者(某对象)。如果synchronized 用于object reference，则取得的lock 将被交给该reference所指对象 

public class TestSyncLock {
	public synchronized void methodOne () {	//修饰方法
		//......
	}
	
	public void methodTwo () {			//修饰object reference
		synchronized (this) {
			//......
		}
	}
	
	public void methodThree () {			//修饰object reference		
		synchronized (syncObj) {		//任意的对象(Integer num、String str等，建议是byte [] bytes = new byte[0];)
			//......
		}
	}
}

       对于方法methodOne()和方法methodTwo()在对象锁定方面功能一致，二者都对this进行同步控制，即获得的lock将给予调用此方法的对象(也就是this所指代的对象)。 由于方法methodOne()和方法methodTwo()都隶属于class TestSyncLock，所以lock由TestSyncLock的某个对象获得。但是方法methodThree()则同步控制syncObj所指代的对象。

       如果我们实例化了class TestSyncLock的两个对象，即： 

TestSyncLock lockOne = new TestSyncLock();
TestSyncLock lockTwo = new TestSyncLock();

      对一个对象进行同步控制到底意味着什么呢？它意味着调用类(TestSyncLock )的对象(lockOne )的synchronized方法/块的线程(比如是Trhead threadA )将会取得对象(lockOne )的lock，当另外的一个线程(比如说Trhead threadB )调用相同的对象(lockOne )的synchronized方法/块的时候，由于该对象(lockOne )的lock已经被前一个线程(threadA )所持有，在该lock被释放之前后来的线程(threadB )将无法获得满足。然而，如果另一个线程(threadB )调用的是相同类(TestSyncLock )的其他对象(lockTwo )的synchronized方法/块的话，获得的是对象(lockTwo)的lock，此时就可以执行。

       结论：对同一个对象的synchronized方法/块只能有一个线程调用并执行，若有其他线程则需要等待；但是其他的线程可以访问该对象的其他非synchronized方法/块。对于不同对象的synchronzied方法/块同一时刻可以由多个线程执行。

       举例1.  

public class MyRunnable implements Runnable {
	@Override
	//public void run() {		//输出结果为格式一
	public synchronized void run() {	//输出结果为格式二
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		MyRunnable run = new MyRunnable();
		Thread tone = new Thread(run, "ThreadOne");
		Thread ttwo = new Thread(run, "ThreadTwo");
		tone.start();
		ttwo.start();
	}
}

 

格式一								格式二
ThreadOne synchronized loop 0		ThreadOne synchronized loop 0
ThreadTwo synchronized loop 0		ThreadOne synchronized loop 1
ThreadTwo synchronized loop 1		ThreadOne synchronized loop 2
ThreadOne synchronized loop 1		ThreadOne synchronized loop 3
ThreadOne synchronized loop 2		ThreadOne synchronized loop 4
ThreadTwo synchronized loop 2		ThreadTwo synchronized loop 0
ThreadOne synchronized loop 3		ThreadTwo synchronized loop 1
ThreadTwo synchronized loop 3		ThreadTwo synchronized loop 2
ThreadOne synchronized loop 4		ThreadTwo synchronized loop 3
ThreadTwo synchronized loop 4		ThreadTwo synchronized loop 4

       说明：我们创建了两个线程tone和ttwo，虽说它们两个是不同的对象，但是真正执行的目标对象却是MyRunnable的对象run。也就是说，线程tone和ttwo在启动执行时调用的是相同的对象(run)的synchronized run()方法。当tone.start()后等待执行(这里假设是tone先执行的，因为线程到底哪个先执行是随机的，由CPU分配时间片决定的，尽管我们可以设置优先级 )，当其获得了时间片后开始执行，获得了run对象的lock；当tone线程在执行sleep(1000)后，实际上CPU会将时间片分配给其他线程(我们就假定此时碰巧分配给了线程ttwo)。当ttwo线程去执行run对象的synchronized run()方法时，发现run对象的lock已经被线程tone获得，自己只有等到，在线程tone释放该lock之前，自己无法执行。当线程tone执行完毕，释放了对象run的lock之后，ttwo才可以执行。

       举例2.  

import java.util.Map;
import java.util.HashMap;

public class MapUtil {
	private static Map<String, String> map = new HashMap<String, String>();
	
	public synchronized void putData() {
		for (int j = 0 ; j < 5 ; j++) {
			System.out.println("put data " + j + " into map");
			map.put("key" + j, "" + j);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public synchronized void getData () {
		for (int j = 0 ; j < 5 ; j++) {
			System.out.println(map.get("key" + j));
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	public void sayHello() {
		for(int j = 0 ; j < 5 ; j++) {
			System.out.println("Hello World");
		}
	}
}

 

public class MapUtilRunnable {
	public static void main(String[] args) {
		final MapUtil mapUtil = new MapUtil();
		Thread tone = new Thread(){
			@Override
			public void run() {
				mapUtil.putData();
			}
		};
		Thread ttwo = new Thread(new Runnable() {
			public void run() {
				mapUtil.getData();
			}
		}, "threadTwo");
		tone.start();
		ttwo.start();
	}
}

 

put data 0 into map
put data 1 into map
put data 2 into map
put data 3 into map
put data 4 into map
0 1 2 3 4 

       说明：对于线程tone和ttwo到底哪个先执行是不确定的，只不过我这里执行时碰巧先执行了putData罢了。但是不管是这两个线程那个先执行，比如咱们这里和举例1 一样先假定tone先执行。虽说是两个不同的线程，但是其执行的仍然是同一对象mapUtil的不同synchronized方法，故只能由一个线程(先执行的threadOne)获得其对象锁。当线程threadOne访问mapUtil的getData()方法时，由于该方法是由synchronized修饰的，故当前线程(threadTwo)也会要求对象mapUtil的lock，而其lock已经被线程threadOne获得。不论怎样，对于synchronized实例方法，线程调用时总是获得调用该方法的对象的lock，只要是同一对象，其所有synchronized方法只有一个对象lock 。

      若线程tone和ttwo一个调用synchronized方法，一个调用sayHello()方法的话，则数据为交叉输出。

      举例1和举例2的对象锁都是synchronized(this)中this，即当前对象。

      举例3.  

public class TestSyncNeverPrint extends Thread{
	private int val;
	public TestSyncNeverPrint (int val) {
		this.val = val;
	}
	
	public synchronized void printVal (int val) {
		while (true) {
			System.out.println(val);
		}
	}
	/**
	 * 
	 * 在该程序中1和3会交替输出，而2永远都不会输出
	 */
	public static void main(String[] args) {
		TestSyncNeverPrint test = new TestSyncNeverPrint(1);
		test.start();
		Bar bar = new Bar(test);
		bar.start();
		TestSyncNeverPrint other = new TestSyncNeverPrint(3);
		other.start();
	}
}

class Bar extends Thread {
	private TestSyncNeverPrint test ;
	public Bar (TestSyncNeverPrint test) {
		this.test = test;
	}
	public void run () {
		test.printVal(2);
	}
}

       记住,同步机制(synchronization)锁定的是对象，而不是函数或代码。函数或代码区段被声明为synchronization 并非意味它在同一时刻只能由一个线程执行。

       Java 语言不允许你将构造方法声明为synchronized(那么做会发生编译错误)。原因是当两个线程并发调用同一个构造函数时，它们各自操控的是同一个class 的两个不同实体(对象)的内存

      举例4.

public class MyRunnable implements Runnable {
	byte [] bytes;
	public MyRunnable (byte [] bytes) {
		this.bytes = bytes;
	}
	@Override
	public void run() {	
		synchronized(bytes) {	//此处为methodThree中提到到object reference
			for (int i = 0; i < 10; i++) {
				System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void main(String[] args) {
		byte [] bytes = new byte[0];
		MyRunnable run = new MyRunnable(bytes);
		Thread tone = new Thread(run, "threadOne");
		tone.start();
		MyRunnable run2 = new MyRunnable(bytes);
		Thread ttwo = new Thread(run2, "threadTwo");
		ttwo.start();
	}
}

       说明：两个不同的线程tone和ttwo执行run()方法时，虽说目标对象不同了(一个为对象run、一个为对象run2)，但是在run()方法中同步代码块synchronized(bytes)锁定的对象是bytes，对于两个线程来说，该bytes对象是完全相同的对象，故只能有一个线程获得该对象的lock。

<<To Be Continued>>