Practicle Java笔记 实践46-58（同步&线程部分）

 

实践46

同步机制锁定的是对象，而不是函数或代码。当synchronized被当作函数修饰符时，它所取得的lock被交给函数的调用者。如果synchronized用于object reference，则取得的lock交给该reference所指的对象。（因此同一类2个不同对象之间加this锁是无效的，因为不是同一个锁）

Java不允许将构造函数声明为synchronized。当两个线程并发调用一个构造函数的时候，它们各自操控的是同一个class的两个不同实体的内存。但如果构造函数内部包含竞争共享资源的代码，则必须同步控制以回避冲突。

实践47

当调用一个synchronized static函数时，获得的lock将与[定义该函数]之class的Class对象相关联，而不是与调用函数的那个对象相关联。当对一个class literal调用其synchronized 区段时，获得的也是同样那个lock，也就是[与特定Class 对象相关联]的lock

看一段代码：

 

	class Foo implements Runnable{
		public synchronized void printM1(){
			while(true)
				System.out.println("M1");
		}
		public synchronized static void printM2(){
			while(true)
				System.out.println("M2");
		}
		public void run(){
			printM1();
		}
	}
	
	class Test{
		public static void main(String args[]){
			Foo f=new Foo();
			Thread t=new Thread(f);
			t.start();
			f.printM2;
		}
	}

这段代码最终较差打印了M1和M2 而没有实现同步

原因在于：一个同步的是static函数，而一个是instance函数，printM1取得的是Foo object lock，而printM2取得的则是Foo的Class object lock。

要使上述代码同步可以：1 同步控制公共资源 2 同步控制一个特殊的instance变量

用byte[] lock=new byte[0];是最经济的

实践48

对于[在synchronized函数中可被修改的数据]，应使之成为private,并根据需要提供访问函数。如果访问函数返回的是可变对象(mutable object)，那么应该先cloned(克隆)该对象。

实践49

一般情况下请不要同步化所有函数，同步化不仅造成程序缓慢，并且丧失了并发可能

　　采用“单对象多锁”技术以允许更多并发动作。

实践50

不可分割的操作并不意味着多线程安全。只要多个线程共享某些变量，它们就必须被访问于synchronized函数或区段内，或是被声明为volatile。这样可以确保变量与主内存完全保持一致，从而在任何时刻都得到正确数值。

采用synchronized或是volatile取决于多个因素。如果并发性很红药，且不需要更新很多变量，可以使用volatile，如果要更新许多变量，volatile执行速度会比同步低。如果使用synchronized，只有在取得和释放lock的时候，变量和主内存才进行一致化

两者关系：

synchronized

优点：取得和释放lock时进行私有专用副本和主内存正本的一致化

缺点：清除了并发性的可能

volatile

优点：允许并发性

缺点：每次访问变量就会进行私有专用内存对应主内存的一致化

实践51

同步化某一函数，并不一定就会使其成为“多线程安全”，如果synchronized函数操控着多个函数，而它们并不都是此函数所属class的private instance data，那么你必须对这些对象自身也进行同步化。

对关键词synchronized必须记住，它锁定的是对象而非函数或代码。

实践52

以固定而全局性的顺序取得多个locks(机锁)以避免死锁

实践53

优先使用notifyAll()而非notify()

notify()只唤醒一个线程 而你无法控制唤醒哪一个线程 只有在2个前提下 用notify才是安全的：

1 只有一个线程在等待

2 多个线程正等待同一条件成立，且哪个被唤醒都无所谓

线程式的优先权（priority）不能确保线程一定被notify()唤醒，也不能确定各线程被notifyAll()以何种顺序唤醒。

实践54

针对wait()和notifyAll()使用旋锁（spin locks）

由于被唤醒的线程会从之前调用wait()的地点开始继续向下执行，英雌在等待条件变量时，请总是使用旋锁确保正确结果。如下：

 

	if(condition==true){
		try{
			a.wait()
		}catch(){}
	}

改成

 

	while(condition==true){
		try{
			a.wait()
		}catch(){}
	}

从而保证唤醒后条件仍然成立没有被改变

实践55

使用wait(),notifyAll()代替轮询

实践56

当一个对象被锁定，有可能其他线程会因同一个object lock而受阻（blocked），假如你对上锁对象的object reference重新赋值，其他线程内悬而未决的那些locks将不再有意义。

所以，不要对上锁对象的object reference重新赋值

实践57

不要调用stop()和suspend()方法

实践58

通过线程间协作来终止线程

 

	private volatile boolean stop;
	public void stopThread(){
		stop=true;
	}
	public void run(){
		while(!stop){}
		//do Clean Works...
	}

很可惜这里必须用到轮询 并且注意stop变量被声明为volatile以确保值永远是最新的