线程总结

类Thread 和 接口Runnable 区别

·Runnable 只有一个run()方法. 如果要执行,还需要new Thread 来帮忙start()
·Thread 是类,需要继承,相对于接口来说,不是很灵活.

调用了start()方法,并不意味着立马执行这个线程.而是处于阻塞状态(准备就绪).

Thread 的常用方法

void interrupt() //中断线程

boolean isInterrupted() //测试线程是否已经中断。

static boolean interrupted() // 测试当前线程是否已经中断。

void join() //等待该线程终止
在方法method1中调用了 线程2的start()方法,会两个线程同时跑,当调用thread2.join()方法的话,就会导致方法method1的时间片被thread2占用.直到thread2执行完.

static void yield() //暂停当前正在执行的线程对象，并执行其他线程。

void setPriority(int newPriority) //更改线程的优先级。
static int MAX_PRIORITY //线程可以具有的最高优先级。
static int MIN_PRIORITY //线程可以具有的最低优先级。
static int NORM_PRIORITY//分配给线程的默认优先级。

一个线程执行了这个代码块,其他线程给我等着,别想和我抢.
synchronized(this){
//代码块
}

还可以对方法进行资源锁定
public synchronized void doSomeThing(){}

/**
 * 
 * @author meiyoudao
 *
 */
public class ThreadTest {

	public static void main(String[] args) {
		/*线程2,3都需要对传入的d类方法操作.
		 *线程2要执行传入的d对象的dos()方法.
		 *线程3要执行传入的d对象的say()方法.
		 *在执行dos方法中,首先锁住d对象中的一个Object1,然后做些事,再锁Object2去完成执行.
		 *在执行say方法中,首先锁住d对象中的一个Object2,然后做些事,再锁Object1去完成执行.
		 *这样,就会形成死锁了,dos方法拿着object1,但需要object2才能继续执行.
		 *say方法拿着object2,需要object1才能继续执行.
		 *
		 *
		 *就好比一个房间有两道门,进门和出门都需要刷卡,A卡刷A门,B卡刷B门.
		 *现在有一个包里面放着两个卡,放着这两个房间的走廊中间.
		 *A来了,拿了这个包,刚准备取出A卡开A门的时候,被B撞了一下,包中的一张卡掉了出来.
		 *然后,A并没有察觉,继续从包里拿了A卡刷开门,进去了.B发现地上有一张卡,于是捡了起来,去B门刷开门进去了.
		 *并且AB都不愿意从来路返回.于是,两个人都问对方要门卡,但是对方都担心给卡给了对方,对方
		 *不把对方持有的卡给自己.于是只是在问别人拿卡,手里一直拽着自己的卡.
		 */

		D d = new D("1","2");
		Thread2 t2 = new Thread2(d);
		Thread3 t3 = new Thread3(d);
		t2.start();
		try {
			Thread.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t3.start();
	}

}
class Thread2 extends Thread
{
	private D d = null;
	public Thread2(D d){
		this.d = d;

	}
	@Override
	public void run() {

		System.out.println("========Thread2=========");
		d.dos();

	}

}

class Thread3 extends Thread
{
	private D d = null;
	public Thread3(D d){
		this.d = d;

	}
	@Override
	public void run() {


		System.out.println("========Thread3=========");
		d.say();

	}

}

class D{
	private Object o1;
	private Object o2;

	public D(Object o11,Object o22){

		this.o1 = o11;
		this.o2 = o22;
	}
	public  void say() {

		synchronized(o1){
		System.out.println("say========O1========");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
			synchronized(o2){
				System.out.println("say======O2==========");
			}
		}

	}

	public void dos() {
		synchronized(o2){
		System.out.println("dos======O1==========");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
			synchronized(o1){
				System.out.println("dos======O2==========");
			}
		}
	}
}

[color=red]一个类中有多个synchronized方法,那么这些方法一次只能被一个线程调用,其他线程想调用synchronized方法,都要等待.除非调用的不是synchronized方法.[/color]


wait 和sleep 的区别
wait 是 Object 的方法,wait之后不会继续持有锁.需要notify/notifyall唤醒.
sleep 是Thread 的方法,一直持有锁.时间到了自然醒.