【Java基础】——多线程

一、多线程概述

1、多线程

进程：正在进行中的程序。程序（任务）的执行过程。每一个进程都有一个执行顺序。该顺序是一个执行路径或者称为一个控制单元。

线程：就是进程中一个负责程序执行的独立控制单元（执行路径），线程控制着进程的执行。一个线程中可以多执行路径。一个进程中至少要有一个线程。

多线程程序在较低的层次上扩展了多任务的概念：一个程序同时执行多个任务。通常，每一个任务称为一个线程(thread)，它是线程控制的简称。可以同时运行一个以上线程的程序称为多线程程序。
多线程与多进程的本质区别：在于每个进程拥有自己的一整套变量，而线程则共享数据。共享变量使线程之间的通信比进程之间的通信更有效、更容易。

2、多线程的好处和弊端：

好处：解决了多部分同时运行的问题
弊端：线程太多会导致效率的降低

其实应用程序的执行都是CPU在做着快速的切换完成的，这个切换是随机的。

3、JVM中的多线程

JVM在启动的时候会有一个进程java.exe。该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称为主线程。

扩展：其实更细节说明JVM多线程，JVM启动不止一个线程，还有负责垃圾回收机制的线程。

二、创建线程的两种方法

1、继承Thread类

步骤：

定义继承Thread类
复写Thread类中的run()方法
调用线程中的start()方法，该方法一方面启动线程，一方面调用了run()方法。

为什么要覆盖run()方法呢？将自定的方法存储在run()方法中，让线程运行。

2、声明实现Runnable接口

步骤：

定义类实现Runnable接口
覆盖Runnable接口中的run()方法，将线程要运行的代码存放在该run方法中。

通过Thread类建立线程对象
将Runnable接口的子类对象作为实际参数传递给Thread的构造函数。为什么要将Runnable接口的子类对象传递给给Tread的构造函数呢？因为，自定义的run方法所属的对象是Runnable接口的子类对象。

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

实现Runnable接口的好处：

将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
避免了java单继承的局限性。

所以在定义线程时，建议使用实现方式。

两种方式的区别：

继承Thread：线程代码存放在Thread子类run()方法中。
实现Runnable：线程代码存在接口的子类的run()方法中。

Java创建线程的两种方式（代码演示）：

/*
	java创建线程的两种方法：
	在java中，创建线程有两种方法，一种是继承Thread类，一种是实现Runnable接口。
	本例子对创建线程的两种方式进行演示。
*/
public class ThreadTest{
	public static void main(String[] args){
		/*ThreadDemo  t1 = new ThreadDemo();
		ThreadDemo  t2 = new ThreadDemo();
		t1.start();
		t2.start();*/
		MyThread t = new MyThread();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		t2.start();
		
	}
}

//创建线程的第一种方式
/*class ThreadDemo extends Thread{
	//复写run()方法
	public void run(){
		for(int i = 0;i < 50;i++){
			System.out.println(Thread.currentThread().getName()+"..."+"run+++"+i);
		}
	}
}*/
//创建线程的第二种方式
class MyThread implements Runnable{
	public void run(){
		for(int i = 0;i < 50;i++){
			System.out.println(Thread.currentThread().getName()+"......"+"MyThread run()");
		}
	}
}

三、线程安全问题

1、线程安全问题产生的原因

①多个线程在操作共享的数据

②操作共享数据的线程有多条。

当一个线程在执行操作共享数据的多条代码过程中，其它线程参与运算，就会导致线程安全问题的产生。

如下列代码所示，线程安全问题的产生代码演示：

/*
	线程安全问题的出现。
	本代码是出现了线程安全问题的代码
*/
class TiketDemo{
	public static void main(String[] args){
		Tiket t = new Tiket();
		
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

class Tiket implements Runnable{
	private int tiket = 10;
	
	public void run(){
		while(true){
			if(tiket > 0){
			try{
				Thread.sleep(1000);
			}
			catch(Exception e){
				
			}
			System.out.println(Thread.currentThread().getName()+"卖了"+tiket--);
			}
		}
	}
}//看如下输出结果。。居然买了 -1  -2 票。。。。出现了线程安全问题
/*
Thread-1卖了9
Thread-0卖了10
Thread-2卖了8
Thread-3卖了7
Thread-1卖了6
Thread-0卖了5
Thread-3卖了4
Thread-2卖了4
Thread-0卖了3
Thread-1卖了2
Thread-2卖了1
Thread-3卖了0
Thread-1卖了-1
Thread-0卖了-2
*/

2、线程安全问题的解决

①解决问题的思路：将多余操作共享数据的代码封装起来。

②java中，用同步代码块或者同步函数可以解决这个问题。

同步代码块（用法如下）

synchronized（对象）
{需要被同步的代码}
同步可以解决安全问题的根本原因就在那个对象上，对象就如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取了cpu的执行权，也进不去，因为没有获取锁。

同步函数

同步函数的格式是在函数上加上synchronized修饰符即可。

③同步的前提：

必须要有两个或者以上的线程
必须是多个线程使用同一个锁

④同步的好处和弊端：

好处：解决了线程安全问题
弊端：相对降低效率，因为同步外的线程都会判断同步锁，较为消耗资源。

线程安全问题的解决（代码实例，沿用上面出现安全问题的例子）：

/*
	线程安全问题的出现。
	本代码是出现了线程安全问题的代码
*/
class TiketDemo{
	public static void main(String[] args){
		Tiket t = new Tiket();
		
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

class Tiket implements Runnable{
	private int tiket = 10;
	
	// Object obj = new Object();
	public void run(){
		while(true){
			sale();//调用同步函数。
			//解决方案一、加入同步代码块
			/*synchronized(obj){
				if(tiket > 0){
					try{
					Thread.sleep(1000);
					}
					catch(Exception e){
				
					}
					System.out.println(Thread.currentThread().getName()+"卖了"+tiket--);
				}
			}*/
			
			//解决方案二：同步函数
		}
	}
	//同步函数。
	public synchronized void sale(){
		if(tiket > 0){
			try{
				Thread.sleep(1000);
			}
			catch(Exception e){
				
			}
			System.out.println(Thread.currentThread().getName()+"卖了"+tiket--);
		}
	}
}

3、线程状态

①线程可以有如下六种状态

New(新生):新建状态，至今尚未启动
Runnable(可运行):运行状态，正在Java虚拟机中执行了的线程处于这种状态
Blocked(被阻塞):受到阻塞并等待某个监听器的锁的线程处于这个状态
Waiting(等待):冻结状态
Timed Waiting(计时等待):等待状态
Terminated(被终止):已退出

要确定一个线程的当前状态，可以调用getState方法。

②线程状态图

4、线程间通信——等待唤醒机制

概念：多个线程在操作同一个资源，但是操作的动作不同。

①等待唤醒机制

a、涉及的方法：

wait():让线程处于冻结状态，被wait的线程会被存储到线程池中。
notify():随机选择一个在该对象上调用wait方法的线程，解除其阻塞状态。
notifyAll():接触那些在该对象上调用wait方法的线程的阻塞状态。

wait() notify() notifyAll全都使用在同步中！因为要对持有监视器(锁)的线程进行操作。所以要使用在同步中，因为只有同步才有锁。

b、为什么这些方法要定义在Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识他们所操作线程持有的锁。只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒，不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

c、等待唤醒机制代码实例：

/*
	线程间的通信：其实就是多个线程在操作同一个资源，但操作的动作不同。
	如一个写入线程，一个读出线程。
	等待唤醒机制。
*/
//资源类
class Res
{
	String name;
	String sex;
	boolean flag = false;//定义一个标记，初始为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="huangxiang";
					r.sex="nan";
				}
				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();

		Input in = new Input(r);
		Output out = new Output(r);

		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		//启动线程
		t1.start();
		t2.start();
	}
}

d、在JDK1.5以后，出现了新的lock接口，将同步synchronized替换成显示的Lock操作。将Object中wait，notify，notifyAll，替换成了Condition对象。该Condition对象可以通过Lock锁进行获取，并支持多个相关的Condition对象。

该接口中的方法摘要如下：

lock()：获取锁
lockInterruptibly()：如果当前线程未被中断，则获取锁
newCondition()：返回绑定到此 Lock 实例的新Condition
实例。
tryLock()：仅在调用时锁为空闲状态才获取该锁。
tryLock(long time,TimeUnit unit)：如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁
unlock()：释放锁。

下面用生产者消费者问题来演示升级后的线程间通信问题：

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锁 进行获取。
该示例中，实现了本方只唤醒对方操作。

Lock:替代了Synchronized
	lock 
	unlock
	newCondition()

Condition：替代了Object wait notify notifyAll
	await();
	signal();
	signalAll();
*/
class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;//设置标记
			//  t1    t2
	private Lock lock = new ReentrantLock();
	//创建两个Condition对象，分别控制等待或唤醒本方和对方线程。
	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();
		}
		
	}
}
//生产者线程
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)
			{
			}
		}
	}
}

5、停止线程

线程的停止有以下两个原因：

因为run方法正常退出而自然死亡。
因为一个没有捕获的异常终止了run方法而意外死亡。

特别是，可以调用线程中的stop方法杀死一个线程，该方法抛出ThreadDeath错误对象，由此杀死线程，但是，stop方法已经过时，不要在自己的代码中调用它。

那么，现在我们如何来停止线程呢？就是让run方法结束。

方案一：多线程运行通常是循环结构，只要控制了循环，就可以让run方法结束。如下列代码所示，我们在首先设置一个标记flag，在该线程执行一段时间之后，将标志设置为false，则该run方法结束，自然线程也就结束了。

public  void run()
{
	while(flag)
	{	
		System.out.println(Thread.currentThread().getName()+"....run");
	}
}

方案二：在方案一中的解决方案可以解决一般情况下线程的停止，但是有一种特殊情况，即当线程处于冻结状态时，方法读取不到该标记，那么线程也就不会结束，此时，我们就需要使用Thread类中的innerrupt()方法对冻结状态进行清除，让线程恢复到运行状态。如下列代码所示：

class StopThread implements Runnable
{
	private boolean flag =true;
	public  void run()
	{
		while(flag)
		{
			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.start();
        t2.start();	

		int num = 0;
		while(true)
		{
			if(num++ == 60)
			{
				t1.interrupt();//清除冻结状态
				t2.interrupt();
				st.changeFlag();//改变循环标记
				break;
			}
			System.out.println(Thread.currentThread().getName()+"......."+num);
		}
		System.out.println("over");
	}
}

6、守护线程（Daemon Thread）

守护线程和普通线程在写法上没什么区别，我们可以通过调用t.setDaemon(true)将线程转为守护线程。守护线程唯一的用途是为其它线程提供服务，当只剩下守护线程时，虚拟机就退出了，如果只剩下守护线程，那么就没有必要继续运行程序了。