黑马程序员_多线程

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

  

   创建线程方式一，继承Thread类，子类覆盖父类中run方法，将线程运行代码存放在run中。建立子类对象的同时线程也被创建。通过调用start方法开启线程。

  创建线程方式二，实现Runnable接口。1.子类覆盖接口中的run方法。 2.通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。

3.Thread类对象调用start方法开启线程。

  线程的四种状态

  

  同步（synchronized）

  格式：

  synchronized（对象）

  {

    需要同步的代码；

  }

  同步可以解决安全问题的根本原因就在那个对象上。 该对象如同锁的功能。

  同步的前提：同步需要两个或者两个以上的线程。多个线程使用的是同一个锁。

   同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

  同步函数，格式：在函数上加上synchronized修饰符即可。synchronized 关键字，代表这个方法加锁,相当于不管哪一个线程，每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程,有的话要等正在使用这个方法的线程运行完这个方法后再运行此线程。没有的话,直接运行，也就是说锁住的代码一个线程运行完之后  其他线程才能抢占cpu的资源开始执行

  wait(),sleep()区别，wait():释放cpu执行权，释放锁。sleep():释放cpu执行权，不释放锁。

  停止线程的方法，1.定义循环结束标记，因为线程运行代码一般都是循环，只要控制了循环即可。2.使用interrupt（中断）方法。该方法是结束线程的冻结状态，使线程回到运行状态中来。 注：stop方法已经过时不再使用。

  线程类的其他方法setPriority(int num)，setDaemon(boolean b)，join()。

  

/*
*生产者/消费者
*/
class ProducerConsumerDemo 
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();

		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);

		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);

		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}

/*
对于多个生产者和消费者。
定义while判断标记，是为了让被唤醒的线程再一次判断标记。
定义notifyAll，是因为需要唤醒对方线程，只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待。
*/
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
	/*
	* 同步函数，格式：在函数上加上synchronized。
	  synchronized代表给这个方法加锁,意思是每次有线程运行到这个方法时,都要检查有没有其它线程正在执行这个方法中的代码
	  ,若有则要等正在执行这个方法中代码的线程运行结束，其他线程才能抢占CPU资源，获得执行权。
	*/
			//  t1    t2
	public synchronized void set(String name)
	{
		while(flag)
			//等待，让消费者去消费
			try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
		this.name = name+"--"+count++;

		System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
		flag = true;
		//唤醒消费者
		this.notifyAll();
	}


	//  t3   t4  
	public synchronized void out()
	{
		while(!flag)
			//等待，让生产者去生产
			try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
		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();
		}
	}
}

import java.util.concurrent.locks.*;

/*
*生产者/消费者代码优化
*/
class ProducerConsumerDemo2 
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();

		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);

		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);

		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}

/*
JDK1.5 中提供了多线程升级解决方案，即将Synchronized替换成Lock操作
，将Object中的wait，notify，notifyAll，替换了Condition对象。


	lock 
	unlock
	newCondition()
*/
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
			//  t1    t2
	//Lock替代了Synchronized
	private Lock lock = new ReentrantLock();//创建一把锁
	//Object替换成了Conditon
	private Condition condition_pro = lock.newCondition();//创建一个Condition对象
	private Condition condition_con = lock.newCondition();



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

			System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
			flag = true;
			//与notify类似
			//但notify可能会出现唤醒本方线程的情况
			//而signal只唤醒对方线程
			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();
		}
		
	}
}

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)
			{
			}
		}
	}
}