黑马程序员——java编程那些事儿____多线程（二）

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

 一 多线程之间的通信

1，多线程间通信概述

多线程间通讯就是多个线程在操作同一资源,但是操作的动作不同.

        (1)为什么要通信

多线程并发执行的时候, 如果需要指定线程等待或者唤醒指定线程, 那么就需要通信.比如生产者消费者的问题，

生产一个消费一个,生产的时候需要负责消费的进程等待,生产一个完成后需要唤醒负责消费的线程,

同时让自己处于等待，消费的时候负责消费的线程被唤醒，消费完生产的产品后又将等待的生产线程唤醒，

然后使自己线程处于等待。这样来回通信，以达到生产一个消费一个的目的。

        (2)怎么通信

在同步代码块中, 使用锁对象的wait()方法可以让当前线程等待, 直到有其他线程唤醒为止.

使用锁对象的notify()方法可以唤醒一个等待的线程，或者notifyAll唤醒所有等待的线程.

多线程间通信用sleep很难实现，睡眠时间很难把握。

2，等待唤醒机制 wait()与notify()

     

（1）wait()、notify()、notifyAll()

          wait():使一个线程处于等待状态，并且释放所持有的对象的lock。 

          notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，

                      而是由JVM确定唤醒哪个线程(一般是最先开始等待的线程)，而且不是按优先级。 

          Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

               注意：sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。 

     

（2）为什么wait()、notify()、notifyAll()这些用来操作线程的方法定义在Object类中？

            (1)这些方法只存在于同步中；

            (2)使用这些方法时必须要指定所属的锁，即被哪个锁调用这些方法，只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒，也即是说

        等待和唤醒必须是同一个锁

            (3)而锁可以是任意对象，所以任意对象调用的方法就定义在Object中。

/*
线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。
*/
class Res
{
	private String name;
	private String sex;
	private boolean flag = false;

	public synchronized void set(String name,String sex)
	{
		if(flag)
			try{this.wait();}catch(Exception e){}
		this.name = name;
		
		this.sex = sex;
		flag = true;
		this.notify();
	}
	public synchronized void out()
	{
		if(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(name+"........"+sex);
		flag = false;
		this.notify();
	}
}

class Input implements Runnable
{
	private Res r ;
	Input(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		int x = 0;
		while(true)
		{
			if(x==0)				
				r.set("mike","man");				
			else	
				r.set("丽丽","女女女女女");				
			x = (x+1)%2;
		}
	}
}

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


class  InputOutputDemo2
{
	public static void main(String[] args) 
	{
		Res r = new Res();

		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
		/*
		Input in = new Input(r);
		Output out = new Output(r);

		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);

		t1.start();
		t2.start();
		*/
	}
}

（3）生产者与消费者

/*
对于多个生产者和消费者为什么要定义while判断标记
   原因就是让被唤醒的线程再一次判断标记

为什么要定义notifyAll
   因为需要唤醒对方线程，因为只用notify容易出现只唤醒本方线程的情况，导致程序中
   的所有线程都等待
*/

class  ProducerConsumerDemo
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();
		new Thread((new Producer(r))).start();
		new Thread((new Consumer(r))).start();
		
	}
}

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
	public synchronized void set(String name)
	{
		while(flag)
			try{this.wait();}catch(Exception e){}
		this.name = name+""+count++;
		System.out.println(Thread.currentThread().getName()+"....生产者+..."+this.name);
		flag = true;
		this.notifyAll();
	}
	public synchronized void out()
	{
		while(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"....消费者+..."+this.name);
		flag = false;
		this.notifyAll();
	}
}

class Producer implements Runnable
{
	private Resource res;
	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			res.set("+商品-");
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;
	Consumer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			res.out();
		}
	}
}

（4）jdk1.5升级版本 Lock 和 Condition

           实现提供比synchronized方法和语句可获得的更广泛的锁的操作，可支持多个相关的Condition对象，Lock是个接口，锁是控制多个线程对共享数据进行访问的工具。

JDK1.5中提供了多线程升级的解决方案：

将同步synchonized替换成了显示的Lock操作，将Object中的wait、notify、notifyAll替换成了Condition对象。

该对象可以Lock锁进行获取

Lock的方法摘要：

void lock()  获取锁。 

Condition newCondition() 返回绑定到此 Lock 实例的新 Condition 实例。 

void unlock() 释放锁。

Condition方法摘要：

void await() 造成当前线程在接到信号或被中断之前一直处于等待状态。

void signal() 唤醒一个等待线程。          

void signalAll() 唤醒所有等待线程。

/*
jdk1.5 新版本 提供了多线程的解决方案
将同步synchronized替换成现实lock操作
将object中的wait，notify notifyAll，替换成了condition对象
该对象可以Lock锁进行获取。
该实例中，实现了本方只唤醒对方的操作
*/
import java.util.concurrent.locks.*;
class  ProducerConsumerDemo2
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();
		new Thread((new Producer(r))).start();
		new Thread((new Consumer(r))).start();
		
	}
}
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_por.await();
			this.name = name+""+count++;
			System.out.println(Thread.currentThread().getName()+"....生产者..."+this.name);
			flag = true;
			
			condition_con.signalAll();
		}
		finally
		{
			lock.unlock();//释放锁的动作一定要执行。
		}
		
	}
	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.signalAll();
		}
		finally
		{
			lock.unlock();
		}
		
	}
}

class Producer implements Runnable
{
	private Resource res;
	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.set("+商品-");
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;
	Consumer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.out();
			}
			catch (InterruptedException e)
			{
			}
		}
	}
}

 二 线程的操作

1 停止线程

 

stop方法已经过时，如何停止线程？

停止线程的方法只有一种，就是run方法结束。如何让run方法结束呢？

开启多线程运行，运行代码通常是循环体，只要控制住循环，就可以让run方法结束，也就是结束线程。

特殊情况：当线程属于冻结状态，就不会读取循环控制标记，则线程就不会结束。

为解决该特殊情况，可引入Thread类中的Interrupt方法结束线程的冻结状态；

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

2 void interrupt() 中断线程: 

      中断状态将被清除，它还将收到一个 InterruptedException

3  setDaemon(boolean on) 守护线程（后台线程）

setDaemon(boolean on):将该线程标记为守护线程或者用户线程。

当主线程结束，守护线程自动结束，比如圣斗士星矢里面的守护雅典娜，

在多线程里面主线程就是雅典娜，守护线程就是圣斗士，主线程结束了，守护线程则自动结束。

当正在运行的线程都是守护线程时，java虚拟机jvm退出；所以该方法必须在启动线程前调用；

守护线程的特点：

        守护线程开启后和前台线程共同抢夺cpu的执行权，开启、运行两者都没区别，

        但结束时有区别，当所有前台线程都结束后，守护线程会自动结束。

/*
stop方法已经过时

如何停止线程？
只有一种方法，run方法结束。
开启多线程运行，运行代码是循环结构。
只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊清况:
当线程处于了冻结状态就不会读取到标记，那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除（interrupt）。
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

Thread类中提供了该方法 interrupt();
*/

class StopThread implements Runnable
{
	private boolean flag = true;
	public synchronized void run()
	{
		while (flag)
		{
			try
			{
				wait();//冻结
			}
			catch (InterruptedException e)//使用interrupt()会有这样的异常（相当于受伤了）
			{
				System.out.println(Thread.currentThread().getName()+".....Exception");
				flag = false;//恢复到运行状态了，就可以使线程结束
			}
			System.out.println(Thread.currentThread().getName()+".....run");
		}
	}
	public void changeFlag()
	{
		flag = false;//改变
	}
}
class  StopThreadDemo
{
	public static void main(String[] args) 
	{
		StopThread st = new StopThread();
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);

		//t1.setDaemon(true);//守护线程：当正在运行的线程都是守护线程时，java虚拟机退出，该方法必须在启动线程前调用
		//t2.setDaemon(true);
		t1.start();
		t2.start();

		int num = 0;
		while(true)
		{
			if(num++ == 60)
			{
				
				t1.interrupt();//将处于冻结状态的线程强制清除
				t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"........."+num);
		}
		System.out.println("over");
	}
}

4 join 加入一个线程

void join() 等待该线程终止。

void join(long millis)  等待该线程终止的时间最长为 millis 毫秒。throws InterruptedException   

     

特点：当A线程执行到B线程的join方法时，A就会等待B线程都执行完，A才会执行

作用: join可以用来临时加入线程执行；

5 多线程优先级：yield()方法

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

setPriority(int newPriority):更改线程优先级

int getPriority() 返回线程的优先级。

String toString() 返回该线程的字符串表示形式，包括线程名称、优先级和线程组

           

(1)MAX_PRIORITY:最高优先级(10级)

(1)Min_PRIORITY:最低优先级(1级)

(1)Morm_PRIORITY:默认优先级(5级)

/*
Join：
当A线程执行到了B线程的join()方法时，A线程就会等待，等B线程都执行完，A才会执行。
join可以用来临时加入线程执行。
*/
class Demo implements Runnable
{
	public void run()
	{
		for (int x=0;x<70 ;x++ )
		{
			System.out.println(Thread.currentThread().toString()+"...."+x);
			Thread.yield();//临时释放用的，稍微减缓运行，而且能达到使线程平均运行的效果

		}
	}
}
class JoinDemo 
{
	public static void main(String[] args) throws Exception
	{
		Demo d = new Demo();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		t1.start();

		//t1.join();//可以临时加入一个线程
		
		//t1.setPriority(Thread.MAX_PRIORITY);//设置优先级


		t2.start();

		for (int x=0; x<80 ;x++ )
		{
			System.out.println("main..."+x);
		}
		System.out.println("over");
	}
}

三 开发如何写线程

 (1)开发这样写代码

//开发这样写多线程，使匿名内部类
class ThreadTest
{
	public static void main(String[] args) 
	{
		//一个线程
		new Thread()
		{
			public void run()
			{
				for(int x=0;x<100;x++)
				{
					System.out.println(Thread.currentThread().getName()+"Hello"+x);
				}
			}
		}.start();

		//两个线程
		for(int x=0;x<100;x++)
		{
			System.out.println(Thread.currentThread().getName()+"Hello"+x);
		}
		
		//三个线程
		Runnable r = new Runnable()
		{
			public void run()
			{
				for(int x=0;x<100;x++)
				{
					System.out.println(Thread.currentThread().getName()+"Hello"+x);
				}
			}
		};
		new Thread(r).start();
		
		/*new Test1().start();*/
	}
}

/*
//还可单独建一个类，但是这样麻烦
class Test1 extends Thread
{
	public void run()
	{
		for(int x=0;x<100;x++)
		{
			System.out.println(Thread.currentThread().getName()+"Hello"+x);
		}
	}
}

*/

（2）jdk1.5新特性创建线程

总结一下张孝祥老师两个面试题里的多线程

//计时器
//方式一
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
	new Runnable(){
		public void run(){

		}
	},
	1,
	1,
	TimeUnit.SECONDS
);
//方式二
ScheduledExectorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
	new Runnable(){
		public void run(){

		}
	},
	1,
	1,
	TimeUnit.SECONDS
);

//线程池
//方式一
Executors.newSingleThreadExector().execute(
	new Runnable(){
		public void run(){
		
		}
	}
);
//方式二
ExecutorService pool = Executors.newSingleThreadExecutor();
pool.execute(
	new Runnable(){
		public void run(){
		
		}
	}
);

四 多线程的其他问题

          

1 、什么是 ThreadLocal 类 , 怎么使用它？

ThreadLocal类提供了线程局部 (thread-local) 变量。是一个线程级别的局部变量，并非“本地线程”。

ThreadLocal 为每个使用该变量的线程,提供了一个独立的变量副本，每个线程修改副本时不影响其它线程对象的副本

下面是线程局部变量(ThreadLocal variables)的关键点：

一个线程局部变量(ThreadLocal variables)为每个线程方便地提供了一个单独的变量。

ThreadLocal 实例通常作为静态的私有的(private static)字段出现在一个类中，这个类用来关联一个线程。 

当多个线程访问 ThreadLocal 实例时，每个线程维护 ThreadLocal 提供的独立的变量副本。

常用的使用可在 DAO 模式中见到，当 DAO 类作为一个单例类时，

数据库链接(connection)被每一个线程独立的维护，互不影响。(基于线程的单例)

2 、什么时候抛出 InvalidMonitorStateException 异常 ? 为什么？

调用 wait ()/notify ()/notifyAll ()中的任何一个方法时，如果当前线程没有获得该对象的锁，那么就会抛出 IllegalMonitorStateException 的异常

也就是说程序在没有执行对象的任何同步块或者同步方法时，仍然尝试调用 wait ()/notify ()/notifyAll ()时。由于该异常是 RuntimeExcpetion 的子类，

所以该异常不一定要捕获(尽管你可以捕获只要你愿意作为 RuntimeException，此类异常不会在 wait (),notify (),notifyAll ()的方法签名提及。 

3 、在静态方法上使用同步时会发生什么事？

同步静态方法时会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。

4 、当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？

可以，一个非同步方法总是可以被调用而不会有任何问题。实际上，Java 没有为非同步方法做任何检查，锁对象仅仅在同步方法或者同步代码块中检查。如果一个方法没有声明为同步，即使你在使用共享数据Java照样会调用，而不会做检查是否安全，所以在这种情况下要特别小心。一个方法是否声明为同步取决于临界区访问(critial section access)，如果方法不访问临界区(共享资源或者数据结构)就没必要声明为同步的。

5 、在一个对象上两个线程可以调用两个不同的同步实例方法吗？

不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。所以只有执行完该方法释放对象锁后才能执行其它同步方法。

6 、什么是线程饿死，什么是活锁？

线程饿死和活锁虽然不像死锁一样是常见的问题，但是对于并发编程的设计者来说就像一次邂逅一样。当所有线程阻塞，或者由于需要的资源无效而不能处理，不存在非阻塞线程使资源可用。

JavaAPI 中线程活锁可能发生在以下情形：

当所有线程在程序中执行 Object.wait (0)，参数为 0 的 wait 方法。程序将发生活锁直到在相应的对象上有线程调用 Object.notify ()或者Object.notifyAll ()。

当所有线程卡在无限循环中。

   

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