java 复习笔记——Java对多线程的支持

一）线程的同步
1、在一个程序中，代码段访问了同一个对象从单独的、并发的线程当中，这个代码段就
叫做“临界区”。采用同步的机制对临界区进行保护。
2、同步的两种方式：同步块和同步方法。这两种方式都是通过一个synchronized关键字
来完成的。
A.对于同步块来说，在synchronized后面需要加上一个对象，这个对象是任意的一个
对象。可以定义一个String类型的，也可以定义一个Object类型的对象：
Object obj = new Object();
在synchronized后面加上这个对象：
synchronized(obj)
{
      //保护的代码段
      ……
}
这样就实现了一个同步。

B．*同步方法的实现：
在方法的前面加上synchronized
Public synchronized void method1()
{
}

同步的方法可以完成跟同步块一样的结果。同步块需要有一个对象，同步方法只需要
在方法的前面加上一个synchronized关键字。

3、同步块的实现机制是怎样完成的呢？java语言中每一个对象都有一个监视器，或者叫
做锁。当我们第一个线程进来的时候首先要判断一下obj这个对象的监视器是否被加
锁，如果没有被加锁，那么它就会将obj的监视器加锁，然后往下执行（遇到sleep
睡眠）…如果其它线程执行到Synchronized会判断到obj已经被加锁，那么它们只能
等待。第一个线程执行完受保护的代码后，会将obj的监视器解锁。其它线程就可以
进入到这个同步的代码段中。

同步方法的实现机制又是怎样的呢？当我们一个线程进入这个方法的时候，也需要加
上一把锁，同步的方法是给类中的this变量的监视器加锁。当一个线程进入同步方法
的时候，会察看this对象是否加锁，没有加锁则会加锁。然后进入到方法内部，方法
执行完后，会将this解锁，其它线程在this解锁后才可以进入。
4、同步方法利用的是this所代表的对象的锁。
5、因为静态方法只属于类本身，而不属于某个对象。每个类都对应有一个class对象，同
步静态方法使用的就是方法所在的类所对应的class对象的监视器。


二）线程的死锁

1、 哲学家进餐的问题。
2、 线程1锁住了对象A的监视器，等待对象B的监视器，线程2锁住了对象B的监视器，等待对象A的监视器，就造成了死锁。
3、 Thread类中两个废弃的方法就很容易造成死锁，suspend()、resume()

Wait、notify、nofityAll方法

1、 每一个对象除了有一个锁之外，还有一个等待队列(wait set)，当一个对象刚创建的时候，它的等待队列是空的。
2、我们应该在当前线程锁住对象的锁后，去调用该对象的wait方法。也就是说wait方法只能够在同步方法或者同步块中被调用。但我们调用wait方法的时候，这个线程就进入了这个对象的等待队列当中。
3、 当调用对象的notify方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程。
4、 当调用对象的notifyAll方法时，将从该对象的等待队列中删除所有等待的线程，这些线程将成为可运行的线程。
5、 Wait和notify主要用于producer-consumer这种关系中。
6、 Wait和notify方法必须在一个同步的块或者方法中被调用，并且针对同一对象的等待队列

三）线程的状态

1、 用new创建一个线程的时候，线程就处于new状态。
当调用start方法的时候，线程处于可运行(Runnable)状态。
一个尚未运行的线程是Runnable状态，一个正在运行的线程也是Runnable状态。
当一个正在运行的线程调用yield方法的时候，线程调度器会选择另外一个线程去运行，调用yield方法的线程仍然处于Runnable状态。
当我们调用sleep、wait、suspend或者I/O阻塞时线程就进入Not Runnable状态。当一个线程sleep结束，或者调用了notify方法、resume方法或者I/O操作完成，线程就会从Not Runnable状态返回Runnable状态。
（resume和suspend这两个函数已经被废弃了，不建议我们再使用）
当一个处于可运行状态的线程它的run方法执行完毕或者调用stop方法，线程就进入了Dead状态终止了。
在Not Runnable状态的时候，调用了stop方法，线程也会终止。
（stop方法是用来停止一个线程的，这个方法也已经废弃了，因为这个方法是不安全的，当调用stop方法时，它会解锁先前锁住的所有的监视器，这样的话，其它的线程就可以去访问被保护的对象，导致对象的状态不一致，结果是不可预料的）

四）线程的终止(两种方式) 
1、 设置一个flag变量

class TestThread
{
	public static void main(String[] args)
	{
		Thread1 t1=new Thread1();
		t1.start();
		int index=0;
		while(true)
		{
			if(index++==500)
			{
				t1.stopThread();
				break;
			}
			System.out.println(Thread.currentThread().getName());
		}
		System.out.println("main() exit");
	}
}

class Thread1 extends Thread
{
	private boolean bStop=false;
	public void run()
	{
		while(!bStop)
		{
			System.out.println(getName());
		}
	}
	public void stopThread()
	{
		bStop=true;
	}
}

需要注意的是，当上面代码中的Thread1 类的run()方法如果调用了wait()方法，如下代码。t1线程将无法结束。

class TestThread
{
	public static void main(String[] args)
	{
		Thread1 t1=new Thread1();
		t1.start();
		int index=0;
		while(true)
		{
			if(index++==500)
			{
				t1.stopThread();
				break;
			}
			System.out.println(Thread.currentThread().getName());
		}
		System.out.println("main() exit");
	}
}

class Thread1 extends Thread
{
	private boolean bStop=false;
	public synchronized void run()
	{
		while(!bStop)
		{
			try{				
		  	wait();
			}
			catch (Exception e)
			{
				e.printStackTrace();
			}
			System.out.println(getName());
		}
	}
	public void stopThread()
	{
		bStop=true;
	}
}

2、 interrupt()方法（可以中断一个线程）
解决上面的问题的办法可以使用interrupt()方法。

class TestThread
{
	public static void main(String[] args)
	{
		Thread1 t1=new Thread1();
		t1.start();
		int index=0;
		while(true)
		{
			if(index++==500)
			{
				t1.stopThread();
				t1.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName());
		}
		System.out.println("main() exit");
	}
}

class Thread1 extends Thread
{
	private boolean bStop=false;
	public synchronized void run()
	{
		while(!bStop)
		{
			try
			{
				wait();
			}
			catch(InterruptedException e)
			{
				//e.printStackTrace();
				if(bStop)
					return;
			}
			System.out.println(getName());
		}
	}
	public void stopThread()
	{
		bStop=true;
	}
}

五）购买火车票模型

class TicketsSystem
{
	public static void main(String[] args)
	{
		SellThread st=new SellThread();
		
		new Thread(st).start();
		try
		{
			Thread.sleep(1);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		st.b=true;
		new Thread(st).start();
		//new Thread(st).start();
		//new Thread(st).start();
	}
}

class SellThread implements Runnable
{
	int tickets=100;
	Object obj=new Object();
	boolean b=false;
	public void run()
	{
		if(b==false)
		{
			while(true)
				sell();
		}
		else
		{
			while(true)
			{
				synchronized(obj)
				{
					try
					{
						Thread.sleep(10);
					}
					catch(Exception e)
					{
						e.printStackTrace();
					}
					synchronized(this)
					{
						if(tickets>0)
						{
							
							System.out.println("obj:"+Thread.currentThread().getName()+
									" sell tickets:"+tickets);
							tickets--;
						}
					}
				}
			}
		}
	}
	public synchronized void sell()
	{
		synchronized(obj)
		{
			if(tickets>0)
			{
				try
				{
					Thread.sleep(10);
				}
				catch(Exception e)
				{
					e.printStackTrace();
				}
				System.out.println("sell():"+Thread.currentThread().getName()+
						" sell tickets:"+tickets);
				tickets--;
			}
		}
	}
}

六）生产者和消费者模型

class Test
{
	public static void main(String[] args)
	{
		Queue q=new Queue();//
		Producer p=new Producer(q);//
		Consumer c=new Consumer(q);//
		p.start();
		c.start();
	}
}

class Producer extends Thread
{
	Queue q;
	Producer(Queue q)
	{
		this.q=q;
	}
	public void run()
	{
		for(int i=0;i<10;i++)
		{
			q.put(i);
			System.out.println("Producer put "+i);
		}
	}
}
class Consumer extends Thread
{
	Queue q;
	Consumer(Queue q)
	{
		this.q=q;
	}
	public void run()
	{
		while(true)
		{
			System.out.println("Consumer get "+q.get());
		}
	}
}
class Queue
{
	int value;
	boolean bFull=false;
	public synchronized void put(int i)	{//
		if(!bFull)
		{
			value=i;
			bFull=true;
			notify();//在这里，wait()和notify()实现了不同代码块间的同步。即实现了put(int i)方法和get()方法的同步.
		}
		try
		{
			wait();//在这里，wait()和notify()实现了不同代码块间的同步。即实现了put(int i)方法和get()方法的同步.
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
			
	}
	public synchronized int get()//
	{
		if(!bFull)
		{
			try
			{
				wait();//在这里，wait()和notify()实现了不同代码块间的同步。即实现了put(int i)方法和get()方法的同步.
			}
			catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		bFull=false;
		notify();//在这里，wait()和notify()实现了不同代码块间的同步。即实现了put(int i)方法和get()方法的同步.
		return value;
	}
}

资料网址：http://java.sun.com/docs/books/jls/second_edition/html/jTOC.doc.html
摘自：http://hi.baidu.com/mylife722/blog/item/533c87145b4f284621a4e920.html