java再学习—线程

package syn;

import thread.thread;

public class synch extends thread {
	public int id;
	public experiment data;
	public synch(int id) {
		this.id=id;// TODO Auto-generated constructor stub
	}
	public void run(){
		System.out.println("运行线程："+this.id);
		//data.method(id);
		//data.methodsyn(id);
		data.methodstatic(id);
		System.out.println("结束线程："+id);
	}
	public static void main(String args[]) {
		int n=2;
		synch[] t=new synch[n];
		experiment dExperiment=new experiment();
		for (int i = 0; i < n; i++) {
			t[i]=new synch(i);
			t[i].data=dExperiment;//	两个线程的成员域均指向同一个实例对象，这两个对象之间不相关，分别由不同的
								
			//锁控制，而t0,t1在同步情况下相同时刻只能有一个线程能够进入并运行ti.data所指向的实例对象的同步方法		
			//同步静态方法与该方法所在类的类对象相关联受类对象锁控制（dexperience），非静态与方法所在类的某个实例对象（ti）相关联受实例对象锁控制
			t[i].start();
		}
		System.out.println("方法main结束");
	}
}

运行结果：

方法main结束
运行线程：1
运行线程：0
线程1进入非静态非同步方法
线程0进入非静态非同步方法
线程1离开非静态非同步方法
结束线程：1
线程0离开非静态非同步方法
结束线程：0
方法main结束

使用同步后：
运行线程：0
线程0进入非静态同步方法
运行线程：1
线程0离开非静态同步方法
线程1进入非静态同步方法
结束线程：0
线程1离开非静态同步方法
结束线程：1
方法main结束

运行线程：0
线程0进入静态同步方法
运行线程：1
线程0离开静态同步方法
结束线程：0
线程1进入静态同步方法
线程1离开静态同步方法
结束线程：1

补充：使用同步语句块（基于实例对象data）

public void run(){
		System.out.println("运行线程："+this.id);
		synchronized (data) {
		data.method(id);
		data.methodsyn(id);
		data.methodstatic(id);
		System.out.println("结束线程："+id);
		}
		}

运行线程：0
线程0进入非静态非同步方法
方法main结束
运行线程：1
线程0离开非静态非同步方法
线程0进入非静态同步方法
线程0离开非静态同步方法
线程0进入静态同步方法
线程0离开静态同步方法
结束线程：0
线程1进入非静态非同步方法
线程1离开非静态非同步方法
线程1进入非静态同步方法
线程1离开非静态同步方法
线程1进入静态同步方法
线程1离开静态同步方法
结束线程：1

多线程中同一个实例对象（dexperience）的多个同步方法（method0 ，method1）：

当线程t0进入并运行成员方法method1时ti.data所指向的实例对象锁自动锁上，这时t1处于阻塞态等待线程t0从成员方法method1中退出来，当线程t0输出线程0离开方法0并从成员方法method1中退出来时，ti.data所指向的实例对象锁自动打开，等待虚拟机调度线程进入并运行这个锁所控制的同步方法method1或method2

同步语句块：

public void run(){
	done=false;
	int d=((id%2==0) ? 1:-1);
	System.out.println("运行线程"+id+"(增量为："+d+")");
	try{
		synchronized (Class.forName("threadsum")) {//同步语句块被threadsum类对象锁所控制，所以每次最多只有一个线程进入并运行同步语句块
		System.out.println("线程"+id+"进入同步语句块data"+data);	
		
	for (int i = 0; i < times; i++) {
		for (int j = 0; j < times; j++) {
			data+=d;
			System.out.println("线程："+id+"离开同步语句块data"+data);
			
			}
			}
	
		}
	}

同步语句块参数选择

方法wait ,notify

package threadex;

public class experiment {
	private int tem,pre;
	private boolean ready=false;
	public synchronized void updata(int t,int p) {
		System.out.println("进入更新方法内部");
		if(ready){
			System.out.println("等待数据更新完成");
			try {
				wait();
			} catch (Exception e) {
				// TODO: handle exception
			}
			System.out.println("继续数据更新");
		}
		
		tem=t;
		pre=p;
		System.out.println("更新完成：温度值为"+t+"气压值为："+p);
		ready=true;
		notify();
	}
	public  synchronized void analyze() {
		System.out.println("进入分析方法内部");
		if(!ready){
			try {
				wait();
			} catch (Exception e) {
				// TODO: handle exception
			}
			System.out.println("继续分析");
		}
		int t=tem;
		int p=pre;
		System.out.println("分析完成：温度值为："+t+"气压值为："+p);
		ready=false;
		notify();		
	}
}

死锁问题：

public void run(){
		boolean t=true;
		System.out.println(getName()+"开始运行");
		for (; true; t=!t) {
			synchronized(t?objecta:objectb){
				System.out.println(getName()+"："+(t?"对象A":"对象B")+"被锁住");
				sleep();
				synchronized (t?objectb:objecta) {
						System.out.println(getName()+"："+(t?"对象B":"对象A")+"被锁住");
						sleep();
						System.out.println(getName()+"："+(t?"对象B":"对象A")+"被打开");
			}
				System.out.println(getName()+"："+(t?"对象A":"对象B")+"被打开");
		}
	  }
	}

</pre><pre name="code" class="java">线程1开始运行
线程2开始运行
线程1：对象A被锁住
线程1：对象B被锁住
线程1：对象B被打开
线程1：对象A被打开
<span style="color:#ff0000;">线程1：对象B被锁住
线程2：对象A被锁住</span>

一个线程在运行与对象A相关联的同步语句块，并在等待对象B打开，而同时另一个线程则在运行与对象B相关联的同步语句块，并在等待对象A锁打开