Java多线程

public class J_Thread extends Thread{
	private int m_threadID;
	public  J_Thread(int i){
		m_threadID = i;
		System.out.println("创建线程：" +i);
	}
	
	public void run(){
		for(int i=0; i<3;i++){
			System.out.println("运行线程： " +m_threadID);
			try{
				Thread.sleep((int)(Math.random() *1000);
			}
			catch(InterruptedException e){
				System.err.println("异常InterruptedException: " +e);
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String args[ ]){
		new J_Thread(1).start();
		new J_Thread(2).start();
		System.out.println("方法main结束");
	}
}

后台线程例子

public class J_ThreadDaemon extends Thread{
	public void run(){
		for(int i=0; true ;i++){
			System.out.println("线程在运行："+i);
			try{
				sleep((int)(Math.random() *1000);
			}
			catch(InterruptedException e){
				System.err.println(e);
			}
		}
	}
	public static void main (String args[ ]){
		J_ThreadDaemon t = new J_ThreadDaemon();
		t.setDaemon(true);
		t.start();
		if(t.isDaemon())
			System.out.println("创建一个后台线程：");
		else
			System.out.println("创建一个用户线程：");
		System.out.println("主方法运行结束");
	}
}

线程组：

public class J_Thread{
	public static void main(String args[ ]){
		System.out.print("方法main所在的线程组含有");
		System.out.println(Thread.activeCount() +"个线程");
		Thread t = Thread.currentThread();
		ThreadGroup tg = t.getThreaGroup();
		
		for(; tg!= null; tg.getParent()){
			System.out.print("线程组" +tg.getName());
			System.out.print("含有");
			System.out.println(tg.g=activeCount() + "个线程");
			int n =tg.activeCount();
			Thread [] tList =new Thread[n];
			int m=tg.enumerate(tList);
			for(int i=0;i<m;i++){
				System.out.println("    其中第" +(i+1) +"个线程名为" +tList[i].getName());
			}
		}
	}
}

多线程同步中共享内存的问题:

class J_Experiment{
	public static void mb_sleep(long millis){
		try{
			Thread.sleep(millis);
		}
		catch(InterruptedException e){
			System.err.println("异常InterruptedException :" +e);
			e.printStackTrace();
		}
	}
	public static synchronized void mb_methodStatic(int id){
		System.out.println("线程" +id+"进入静态同步方法");
		mb_sleep(1000);
		System.out.println("线程" +id+ "离开静态同步方法");
	}
	public synchronized void mb_methodSynchronized(int id){
		System.out.println("线程" +id+ "进入非静态同步方法");
		mb_sleep(1000);
		System.out.println("线程" +id+ "离开非静态同步方法");
	}
	public void mb_method(int id){
		System.out.prinln("线程" +id+ "进入非静态非同步方法");
		mb_sleep(1000);
		System.out.println("线程" +id+ "离开非静态非同步方法");
	}
}
public class J_SynchronizedStatic extends Thread{
	public int m_ID;
	public J_Experiment m_data;
	J_SynchronizedStatic(int id){
		m_ID=id;
	}
	public void run(){
		System.out.println("运行线程:" +m_ID);
		m_data.mb_methodSynchronized(m_ID);
		m_data.mb_methodStatic(m_ID);
		m_data.mb_method(m_ID);
		System.out.println("结束线程" +m_ID);
	}
	public static void mian(String args[ ]){
		int n=2;
		J_SynchronizedStatic [] t=new J_SynchronizedStatic[n];
		J_Experiment d=new J_Experiment();
		for(int i=0;i<n;i++){
			t[i]=new J_SynchronizedStatic(i);
			t[i].m_data=d;
			t[i].start();
		}
		System.out.println("方法main结束");
	}
}

基于类对象的同步语句块

public class J_BlockClass extends Thread{
	public static int m_data=0;
	public static int m_times=1000;
	public int m_ID;
	public boolean m_done;
	
	J_BlockClass(int id){
		m_ID=id;
	}
	
	public void run(){
		m_done=false;
		int d=((m_ID%2==0)? 1:-1);
		System.out.println("运行线程：" +m_ID+"(增量为：" +d+")");
		try{
			synchronized (Class.forName("J_BlockClass")){
				System.out.println("线程：" +m_ID+ "进入同步语句块，m_data=" +m_data);
				for(int i=0;i<m_times;i++)
				for(int j=0j<m_times;j++)
					m_data+=d;
				System.out.println("线程:" +m_ID+"离开同步语句块，m_data=" +m_data);
			}
		}
		catch(ClassNotFoundException e){
			e.printStackTrace();
			System.err.prinln(e);
		}
		m_done=true;
		System.out.println("结束线程：" +m_ID);
	}
	public static void main(String args[ ]){
		J_BlockClass t1= new J_BlockClass(1);
		J_BlockClass t2 = new J_BlockClass(2);
		t1.m_done=false;
		t2.m_done=false;
		t1.start();
		t2.start();
		while(!t1.m_done|| !t2.m_done)//等待两个线程运行结束
			;
		System.out.println("结果：m_data=" +m_data);
	}
}

基于实例对象的同步语句块的例子

class J_Experiment{
	public static void mb_sleep(loog millis){
		try{
			Thread.sleep(millis);
		}
		catch(InterruptedException e){
			System.err.println("异常InterruptedException: " +e);
			e.printStackTrace();
		}
		
	}
	public void mb_method1(int id){
		System.out.println("线程" +id+ "进入方法1");
		mb_sleep(1000);
		System.out.println("线程" +id+ "离开方法1");
	}
	public void mb_method2(int id){
		System.out.println("线程" +id+ "进入方法2");
		mb_sleep(1000);
		System.out.println("线程" +id+ "离开方法2");
	}
}

public class J_BlockData extends Thread{
	public int m_ID;
	public J_Experiment m_data;
	J_BlockData(int id){
		m_ID=id;
	}
	
	public void run(){
		System.out.println("运行线程：" +m_ID);
		synchronized(m_data)//实例对象{
			System.out.println("进入同步语句块的是线程："+m_ID);
			m_data.mb_method1(m_ID);
			m_data.mb_method2(m_ID);
			System.out.println("离开同步语句块的是线程："+m_ID);
		}
		System.out.println("结束线程：" +m_ID);
	}
	public static void main(String args[ ]){
		int n=2;
		J_BlockData[ ] t =new J_BlockData[n];
		J_Experiment d= new J_Experiment();
		for(int i=0;i<n; i++){
			t[i]=new J_BlockData(i);
			t[i].m_data=d;
			t[i].start();
		}
		System.out.println("方法main结束");
	}
}

阻塞与唤醒wait();notify()或notifyall()

class J_Experiment{
	private int m_temperature,m_pressure;
	private boolean m_ready=false;
	public synchronized void mb_update(int t,int p){
		System.out.println("进入更新方法内部：");
		if(m_ready){
			System.out.println("   等待数据分析完成...");
			try{
				wait();//等待；
			}
			catch(Exception e){
				e.printStackTrace();
				System.err.println(e);
			}
			System.out.println("     继续更新数据...");
			m_temperature =t;
			m_pressure = p;
			System.out.println("更新完成：温度值为" +t+ ", 气压值为：" +p);
			m_ready=true;
			notify();
		}
		
		public synchronized void mb_analyze(){
			System.out.println("进入数据分析方法内部：");
			if(!=m_ready){
				System.out.println("     等待数据更新完成...");
				try{
					wait();
				}
				catch(Exception e){
					e.printStackTrace();
					System.err.println(e);
				}
				System.out.println("        继续分析数据....");
			}
			int t=m_temperature;
			int p= m_pressure;
			System.out.println("分析完成：温度值为：" +t+ ", 气压值为：" +p);
			m_ready=false;
			notify();
		}
	}
	
	class J_Assistant extends Thread{
		J_Experiment m_data;
		public J_Assistant(J_Experiment d){
			m_data=d;
		}
		public void run(){
			System.out.println("助理线程开始工作");
			int i,j,k;
			for(k=0;k<3;k++){
				i=(int)(Math.random()  *1000);
				j =(int)(Math.random() *1000);
				m_data.mb_update(i,j);
			}
			System.out.println("助理线程结束工作");
		}
	}
	
	class J_Analyst extends Thread{
		J_Experiment m_data;
		public J_Analyst(J_Experiment d){
			m_data=d;
		}
		public void run(){
			System.out.println("分析员线程开始工作");
			for(int k=0;k<3;k++)
				m_data.mb_analyze();
			System.out.println("分析员线程结束工作");
		}
	}
	
	public class J_WaitNotify{
		public static void main(String args[ ]){
			J_Experiment data= new J_Experiment();
			J_Assistant threadA = new J_Assistant(data);
			J_Analyst threadB =new J_Analyst(data);
			threadA.start();
			threadB.start();
			System.out.println("方法main结束");
		}
	}
		
		

可能出现死锁问题：

public class J_Lock extends Thread{
	public static Object m_objectA = new Object();
	public static Object m_objectB = new Object();
	
	J_Lock(String s){
		super(s);
	}
	
	public static void mb_sleep(){
		try{
			Thread.sleep((long)(Math.random() *1000);
		}
		catch(InterruptedException e){
			System.out.println("异常InterruptedException :" +e);
			e.printStackTrace();
		}
	}
	
	public void run(){
		boolean t =true;
		System.out.println(getName() +"开始运行"):
		for( ; true;t!=t){
			synchronized(t ? m_objectA:m_objectB){
				System.out.println(getName() +": " +(t? "对象A" :"对象B") +"被锁住");
				mb_sleep();
				synchronized(t ? m_objectB:m_objectA){
					System.out.println(getName() + ":" +(t ?"对象B" :"对象A") +"被锁住");
					mb_sleep();
					System.out.println(getName() +": " +(t? "对象B" :"对象A") +"的锁打开");
				}
				System.out.println((getName() +":" +(t? "对象A":"对象B")+ "的锁打开"):
			}
		}
	}
	public static void main(String args[ ]){
		J_LOck t1 = new J_LOck("线程1");
		J_Lock t2 = new J_Lock("线程2");
		t1.start();
		t2.start();
	}
}