黑马程序员 java_多线程（二）

 

                            ------- android培训、java培训、期待与您交流！ ----------

 

 

多线程

 

 

 

线程间通信

 

其实就是多个线程在操作同一个资源，

但是操作的动作不同。

 

示意图

 

例子

class Res{
	String name;
	String sex;
	boolean flag = false;
	
	int x=0;
	public synchronized void set(){
		if(flag)
			try{this.wait();}catch(Exception e){}
		if(x==0){
			this.name = "mike";
			this.sex = "man";
		}
		else
		{
			this.name="丽丽";
			this.sex="女女";
		}
		x = (x+1)%2;
		this.flag = true;
		this.notify();
	
	}
	
	public synchronized void get(){
		if(!this.flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(this.name+"..."+this.sex);
		this.flag = false;
		this.notify();
	}
}

class Input implements Runnable{
	private Res r;
	Input(Res r){
		this.r = r;
	}
	public void run(){
		
		while(true){
			r.set();
		}
	}
}

class Output implements Runnable{
	private Res r;
	Output(Res r){
		this.r = r;
	}
	public void run(){
		while(true){
			r.get();
		}
	}
}


public class InputOutDemo {
	public static void main(String[] args) {
		Res r = new Res();
		Input in = new Input(r);
		Output out = new Output(r);
		
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		
		t1.start();
		t2.start();
	}

}

在上面的代码中线程t1和t2，一个在添加姓名和性别，而另一个是在打印姓名和性别。添加时按照一个男一个女的顺序添加。并且保证添加一个打印一个。

上面的代码就是线程间通讯的一个例子。一个线程负责添加，另一个线程负责打印添加的内容。在代码中分别将信息添加方法set()和信息打印方法get()加锁，成为同步函数。两个方法使用的是同一个锁，这就保证了，当有一个线程在对信息进行操作时(包括添加和打印)，其他的线程无法计入同步函数，这样就保证了安全，不会打印出错误信息。

 

 

 

 

同步中的方法

 

wait()： 在其他线程调用此对象的notify() 方法或 notifyAll()方法前，导致当前线程等待。此时线程将释放cpu执行权，并且释放锁，此时其它锁可以进入此同步中。

 

notify()：

唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个wait()方法，在对象的监视器上等待。

简单理解为可唤醒已经失去cpu执行权的线程，使之获得cpu执行资格，当然该线程不一定马上

就会得到cpu执行权，这还要排队等前面的线程释放cpu执行权。另外此方法会优先唤醒，处于同一同步代码中的线程。

 

notifyAll()：

唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个wait方法，在对象的监视器上等待。与notify作用类似。区别在于,它会无差别的唤醒所有等待线程，不会区分是否在同一同步代码中。

 

sleep(long millis):

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

此方法不是同步中特有的,此方法将释放cpu执行权，而不会释放锁。也就是说在同步中，即使线程处于sleep()的状态中，其他线程也进来不了,因为锁没有释放。

 

注意：wait(),notify(),notifyAll(),方法只能在同步中，否则代码运行时会抛出非法监视异常。

 

 

 

 

Lock接口

 

 

JDK1.5 中提供了多线程升级解决方案。将同步Synchronized替换成实现Lock操作。

 

产生原因

 

synchronized可以解决同步中的安全问题，但是也存在一些不足

synchronized方法和代码块，会隐式的为进入这些代码的线程加锁，但代码中有多层锁时，线程

就会依次加上这些锁，并且要按照相反的顺序去释放这些锁，只有在退出相应代码时锁才会被

释放。这种方式太呆板，当需要在同步代码A中释放同步B中的锁定，这种方式就无能为力了。

 

此时我们需要一种更加灵活的方式来处理同步问题，Lock技术就依次产生。Lock技术可提供比synchronized更广泛的操作，下面只介绍与synchronized相关内容。

 

 

 

 

Lock与synchronized的关系

 

1，将synchronized 替换成了Lock接口。

      将隐式锁，升级成了显示锁。

         Lock中的方法

          获取锁：lock();

          放锁：unlock();注意：释放的动作一定要执行，所以通常定义在finally中。

          获释取Condition对象：newCondition();

2，将Object中的wait，notify，notifyAll方法都替换成了Condition的await，signal，signalAll。

       和以前不同是：一个同步代码块具备一个锁，该所以具备自己的独立wait和notify方法。

       现在是将wait，notify等方法，封装进一个特有的对象Condition，而一个Lock锁上可以有多         个Condition对象。

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
			
	private Lock lock = new ReentrantLock();

	private Condition condition_pro = lock.newCondition();
	private Condition condition_con = lock.newCondition();



	public  void set(String name)throws InterruptedException
	{
		lock.lock();
		try
		{
			while(flag)
				condition_pro.await();//t1,t2
			this.name = name+"--"+count++;

			System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
			flag = true;
			condition_con.signal();
		}
		finally
		{
			lock.unlock();//释放锁的动作一定要执行。
		}
	}


	//  t3   t4  
	public  void out()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
				condition_con.await();
			System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
			flag = false;
			condition_pro.signal();
		}
		finally
		{
			lock.unlock();
		}
		
	}
}

 注意lock.unlock()一定要执行，即使发生异常锁得到释放，以便其它线程进入。

 

 

 

线程停止

 

只有一种，run方法结束。

开启多线程运行，运行代码通常是循环结构。

 

只要控制住循环，就可以让run方法结束，也就是线程结束。

 

class StopThread implements Runnable{
	private boolean flag = true;
	public synchronized	void run(){
		while(flag)
		{
			System.out.println(Thread.currentThread().getName()+"..run");
		}
	}
	public void changeFlag()
	{
		flag = false;
	}
}

public class StopThreadDemo {
	public static void main(String[] args) {
		StopThread st = new StopThread();
		
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);
		t1.start();
		t2.start();
		
		int num=0;
		while(true){
			if(num++==60){
				//此时改变标记，flag为false,run方法中的循环结束，线程t1，t2也结束
				st.changeFlag();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"..."+num);
			
		}
		System.out.println("over");
	
	}
}

 

特殊情况：

当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。

需要强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类提供该方法 interrupt();

 

 

class StopThread implements Runnable{
	private boolean flag = true;
	public synchronized	void run(){
		while(flag)
		{
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				System.out.println(Thread.currentThread().getName()+"..Exception");
				//如果不在此处更改标记，下一次循环，线程又将进入冻结状态
				flag = false;
			}
			System.out.println(Thread.currentThread().getName()+"..run");
		}
	}
	public void changeFlag()
	{
		flag = false;
	}
}

public class StopThreadDemo {
	public static void main(String[] args) {
		StopThread st = new StopThread();
		
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);
		t1.start();
		t2.start();
		
		int num=0;
		while(true){
			if(num++==60){
				t1.interrupt();//使线程从冻结状态中恢复过来，此时线程会抛出InterruptedException异常
				t2.interrupt();
				//st.changeFlag();调用此方法不能保证在线程t1和t2进行标记判断前，标记已更改。
				break;
			}
			System.out.println(Thread.currentThread().getName()+"..."+num);
			
		}
		System.out.println("over");
	
	}
}

 

 

 

 

线程中的其它方法

 

join

 

当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。

class Demo implements Runnable{
	public void run()
	{
		for(int x=0;x<100;x++){
			System.out.println(Thread.currentThread().toString()+".."+x);
//			Thread.yield();
			
		}
	}
}


public class JoinDemo {
	public static void main(String[] args) throws InterruptedException {
		Demo d = new Demo();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		
		t1.start();
	//	t1.setPriority(Thread.MAX_PRIORITY);
		t1.join();
		t2.start();

		
		for(int i=0;i<40;i++){
			System.out.println(Thread.currentThread().getName()+".."+i);
		}
		
	}

}

 

 可见当线程t1，执行完成后，才开始接着执行主线程。

 

 

setDaemon

将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。

也就是说，主线程结束时，此线程也会结束，该方法必须在启动线程前调用。

 

 

yield

暂停当前正在执行的线程对象，并执行其他线程。

 

setPriority

更改线程的优先级，优先级范围1-10，api中已定义好了几个常量

MIN_PRIORITY，MAX_PRIORITY，NORM_PRIORITY。

t.setPriority(MAX_PRIORITY)线程t被设置为最大优先级。

 

 

                                         ------- android培训、java培训、期待与您交流！ ----------