黑马程序员-多线程

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

进程：是一个正在执行的程序。每个进程都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。


jvm启动的时候会有一个进程java.exe.
该进程至少有一个线程负责java程序执行，而且这个线程运行代码在main方法中。该线程称为主线程。
jvm启动时，还有负责垃圾回收机制的线程。


创建线程的第一种方式：继承Thread类，复写run方法，调用start方法，启动线程，调用run方法。
为什么要覆盖run方法：因为run方法中存储了线程的运行代码。
new Thread().start(); :启动线程并调用run方法
new Thread().run();  :调用run方法，创建线程但没有运行。
明确：在某一时刻，只能有一个程序在运行(多核除外)，cpu在做着快速切换，已达到看上去同时运行效果。
随机性：执行哪个线程，由cpu说了算。


线程运行状态：


线程有自己的默认编号和名称。
可以通过setName() 和getName()来设置线程名称。


创建线程的第二种方式：实现Runnable接口

• 定义类实现Runnable接口，覆盖Runnable中的run方法
• 通过Thread类建立线程对象，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

自定义的run方法所属对象是Runnable接口的子类对象，要让线程去指定指定对象的run方法，必须明确该run方法所属对象。

• 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

实现方式和继承方式有什么区别：
实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。


两种方式区别：
继承Thread：线程代码存放Thread子类run方法中
实现Runnable：线程代码存放在接口子类的run方法。


多线程运行会出现安全问题：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
另一个线程参与进来执行，导致共享数据的错误。
解决办法：对多条操作共享数据的语句加锁。java对多线程安全问题提供专业的解决方式：同步代码块。


synchronized(对象){}
对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权也进不去，因为没有获取锁。


同步的前提：必须保证同步中只能有一个线程在运行
1.必须要有两个或者两个以上的线程
2.必须是多个线程使用同一个锁。


好处：解决了多线程的安全问题
弊端：多个线程需要判断锁，消耗资源，程序的效率会降低


如何寻找多线程中的安全问题：
1.明确多线程运行代码
2.明确共享数据
3.明确多线程运行代码中哪些语句是操作共享数据的


同步函数使用的锁就是调用该函数的对象即this
静态同步函数使用的锁是类名.class，也就是该类的字节码对象。因为静态进内存时，内存中没有本类对象，但一定有该类对应的字节码文件对象。


验证同步函数使用的对象：

class Test implements Runnable//extends Thread
{
	private static int tick = 100;
	boolean flag = true;
	Object obj = new Object();
	public void run()
	{
		if(flag)
		{
		while(true)
		{
			synchronized(Test.class)//如果验证非静态同步函数，传入this
			{
				if(tick>0)
				{
					
					try
					{
					Thread.sleep(10);
					}
					catch (Exception e)
					{}/**/
				
					System.out.println(Thread.currentThread()+"....."+tick--);
				}


			}
			
		}
		}
		else 
			while(true)
				show();
	}
	public static synchronized void show()//静态同步函数
	{
		if(tick>0)
				{
					
					try
					{
					Thread.sleep(10);
					}
					catch (Exception e)
					{}/**/
				
					System.out.println(Thread.currentThread()+"....."+tick--);
				}
	}
}
class  ThreadDemo
{
	public static void main(String[] args) 
	{
		Test t = new Test();
		new Thread(t).start();
		try{Thread.sleep(10);}catch(Exception e){}
		t.flag = false;
		new Thread(t).start();
	
	}
}

sleep()和wait() 的区别：
sleep：释放cpu执行权，不释放锁
wait：释放cpu执行权，释放锁


死锁：同步中嵌套同步

class Test implements Runnable
{
	private boolean flag;
	Test(boolean flag)
	{
		this.flag = flag;
	}
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(LockClass.locka)
				{
					System.out.println("if locka");
					synchronized(LockClass.lockb)
					{
						System.out.println("if lockb");
					}
				}
			}
		}
		else
		{
			while(true)
			{
				synchronized(LockClass.lockb)
				{
					System.out.println("else lockb");
					synchronized(LockClass.locka)
					{
						System.out.println("else locka");
					}
				}
			}
		}
	}
}
class LockClass
{
	public static LockClass locka = new LockClass();
	public static LockClass lockb = new LockClass();
}


class  DeadLockDemo
{
	public static void main(String[] args) 
	{
		new Thread(new Test(true)).start();
		new Thread(new Test(false)).start();
	}
}

线程间通信：等待唤醒机制*****
wait()  notify()  notifyAll()都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
这些操作线程的方法都定义在Object类中，因为这些方法在操作同步中的线程时，都必须标识
它们所操作线程持有的锁。而锁对应的对象可以是任意的。
且等待和唤醒必须是同一个锁。

class Res
{
	String name;
	String sex;
	boolean flag = false;
}
class Input implements Runnable
{
	private Res r;
	Input(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		int x =0;
		while(true)
		{
			synchronized(r)//操作公共数据时必须是同一个锁
			{
				if(r.flag)
					try{r.wait();}catch(Exception e){}//操作线程的方法必须要标识所属的锁。
				if(x==0)
				{
					r.name = "lisi";
					r.sex = "man";
				}
				else
				{
					r.name = "敏儿";
					r.sex = "女女";
				}
				x = (x+1)%2;
				r.flag = true;
				r.notify();//操作线程的方法必须要标识所属的锁。
			}
		}
	}
}
class Output implements Runnable
{
	private Res r;
	Output(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			synchronized(r)//操作公共数据时必须是同一个锁
			{
				if(!r.flag)
					try{r.wait();}catch(Exception e){}//操作线程的方法必须要标识所属的锁。
				System.out.println(r.name+"....."+r.sex);
				r.flag = false;
				r.notify();//操作线程的方法必须要标识所属的锁。
			}
		}
	}
}
class  InputOutputDemo
{
	public static void main(String[] args) 
	{
		Res r = new Res();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
	}
}

生产者和消费者示例：

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;


	public synchronized void set(String name)
	{
		while(flag)//定义while判断标记，让被唤醒的线程再一次判定标记
			try{this.wait();}catch(Exception e){}
		this.name = name;
		System.out.println(Thread.currentThread().getName()+"...生产者"+this.name+"---"+count++);
		flag = true;
		this.notifyAll();//需要唤醒对方线程，只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。


	}
	public synchronized void out()
	{
		while(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"...消费者......"+this.name+"---"+count);
		flag = false;
		this.notifyAll();
	}
}
class Producer implements Runnable
{
	private Resource r;
	Producer(Resource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.set("+ 商品 + ");
		}
	}
}
class Consumer implements Runnable
{
	private Resource r;
	Consumer(Resource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.out();
		}
	}
}


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

jdk1.5中提供了多线程升级解决方案，将同步synchronized替换成现实Lock操作
将Object中的wait，notify，notifyAll替换成Condition中的await，signal，signalAll
而且一个lock可以支持多个相关Condition对象。实现了本方只唤醒对方操作。

import java.util.concurrent.locks.*;
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();
			this.name = name;
			System.out.println(Thread.currentThread().getName()+"...生产者"+this.name+"---"+count++);
			flag = true;
			condition_con.signal();
		}
		finally
		{
			lock.unlock();
		}
	}
	public void out()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
				condition_con.await();
			System.out.println(Thread.currentThread().getName()+"...消费者......"+this.name+"---"+count);
			flag = false;
			condition_pro.signal();
		}
		finally
		{
			lock.unlock();
		}
	}
}
class Producer implements Runnable
{
	private Resource r;
	Producer(Resource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				r.set("+ 商品 + ");
			}
			catch (InterruptedException e)
			{
			}
		}
	}
}
class Consumer implements Runnable
{
	private Resource r;
	Consumer(Resource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				r.out();
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}
}


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

停止线程：run方法结束。开启多线程运行，运行代码通常都是循环结构，只要控制住循环，就可以让线程结束。
当线程处于冻结状态，就不会读取到标记，那么线程就不会结束。
当没有指定的方式让冻结的线程恢复到运行状态时，这时就需要对冻结进行清除。强制让线程恢复到运行状态中来。
这样就可以操作标记让线程结束。Thread类中提供了该方法 interrupt();


守护线程：setDaemon(boolean flag) 
在线程开启前将线程设置为守护线程(后台线程)，当所有线程都是守护线程时，jvm退出。


join方法：当A线程执行到了B线程的join方法时，A就会等待，等B线程执行结束，A才会执行。
join可以用来临时加入线程执行。
注意：j oin方法只是让所在线程释放cpu执行权。


优先级：1-10，默认是5.Thread类中进行了常量定义MAX_PRIORITY MIN_PRIORITY NORM_PRIORITY
可以使用setPriority()方法设置优先级。


yield方法：暂停正在执行的线程对象，并执行其他线程。
可以减缓线程运行频率，平衡线程运行机会。