黑马程序员---多线程

一、概念

1.线程概念

线程，是程序执行流的最小单元。线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。

2.多线程：

在计算机编程中，一个基本的概念就是同时对多个任务加以控制。
用途：
使用线程可以把占据时间长的程序中的任务放到后台去处理，用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。程序的运行速度可能加快，在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等等。

二、线程实现

1.创建线程的三种方式

        继承Thread类；

实现Runnable接口；

使用ExecutorService、Callable、Future实现有返回结果的多线程。（JAVA1.5后的新特性，有返回值）

2、 继承方式

第一种方式就是通过继承Thread类，然后复写其run方法的方式来创建线程。

package threadExec;
class MyThread extends Thread
{
	@Override
	public void run() {
		//添加线程执行的语句
	}
}
public class MyThreadDemo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread t = new MyThread();
		t.start(); //调用系统的native方法开启线程
	}
}

3、实现方式

第二种方式就是通过继承Thread类，然后复写其run方法的方式来创建线程。

<pre name="code" class="java">package threadExec;
class MyThread implements Runnable
{
	@Override
	public void run() {
		//添加线程执行的语句
	}
}
public class MyThreadDemo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Thread t = new Thread(new MyThread());
		t.start(); //调用系统的native方法开启线程
	}
}

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

4、实现方式

第三种方式就是使用ExecutorService、Callable、Future实现有返回结果的多线程。此种方式是JDK1.5后的新特性

package threadExec;
import java.util.concurrent.*;  
import java.util.Date;  
import java.util.List;  
import java.util.ArrayList;  

/** 
 * 有返回值的线程 
 */  
@SuppressWarnings("unchecked")  
public class MyThreadDemo {  
	public static void main(String[] args) throws ExecutionException,  
	InterruptedException {  
		int taskSize = 5;  
		// 创建一个线程池  
		ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
		// 创建多个有返回值的任务  
		List<Future> list = new ArrayList<Future>();  
		for (int i = 0; i < taskSize; i++) {  
			Callable c = new MyCallable(i + " ");  
			// 执行任务并获取Future对象  
			Future f = pool.submit(c);  
			list.add(f);  
		}  
		// 关闭线程池  
		pool.shutdown();  

		// 获取所有并发任务的运行结果  
		for (Future f : list) {  
			// 从Future对象上获取任务的返回值，并输出到控制台  
			System.out.println(f.get().toString());  
		}  
	}  
}  

class MyCallable implements Callable<Object> {  
	private String taskNum;  

	MyCallable(String taskNum) {  
		this.taskNum = taskNum;  
	}  

	public Object call() throws Exception {  
		Thread.sleep(1000); 
		Date date = new Date();
		return taskNum + "任务返回运行结果,当前时间【" + date.getTime() + "】";  
	}  
}  

三、线程存在状态    

状态说明：

被创建：等待启动，调用start启动。

        运行状态：具有执行资格和执行权。

        临时状态（阻塞）：有执行资格，但是没有执行权。

        冻结状态：遇到sleep（time）方法和wait（）方法时，失去执行资格和执行权，sleep方法时间到或者调用notify（）方法时，获得执行资格，变为临时状态。

        消亡状态：stop（）方法（已过时），或者run方法结束。

四、线程安全

1.原因：

        当多条语句在操作同一线程共享数据时，一个线程对多条语句只执行了一部分，还没用执行完，另一个线程参与进来执行。导致共享数据的错误。

简单的说就两点：

        a、多个线程访问出现延迟。

        b、线程随机性。

注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

package threadExec;
class TicketDemo implements Runnable
{
	private int ticket = 100;
	public void run()
	{
		while(ticket>0)
		{
			System.out.println("ticket="+ticket);
			ticket=ticket-1;
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
	}
}

public class MyThreadDemo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
	TicketDemo t = new TicketDemo();
	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();
	}
}

运算结果出错

2、解决办法——同步

1.同步方法

        对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行，在java中对于多线程的安全问题提供了专业的解决方式——synchronized（同步）。这里也有两种解决方式，一种是同步代码块，还有就是同步函数。都是利用关键字synchronized来实现。

a，同步代码块

        用法：
                  synchronized（对象）

                  {需要被同步的代码}

package threadExec;
class TicketDemo implements Runnable
{
	private int ticket = 100;
	public void run()
	{
		while(ticket>0)
		{
			synchronized (this) {
				System.out.println("ticket="+ticket);
				ticket=ticket-1;
			}

		}
	}
}

同步可以解决安全问题的根本原因就在那个对象上。其中对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

b，同步函数

        格式：

                在函数上加上synchronized修饰符即可。

package threadExec;
class TicketDemo implements Runnable
{
	private int ticket = 100;
	public synchronized void run()
	{
		while(ticket>0)
		{
			System.out.println("ticket="+ticket);
			ticket=ticket-1;
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
	}
}

        那么同步函数用的是哪一个锁呢？

        函数需要被对象或类调用。那么函数都有一个所属对象引用或类引用。所以非静态同步函数使用的锁是this，静态同步函数所用的锁是类的二进制文件对象（Class.class).

2.同步前提

        a，必须要有两个或者两个以上的线程。

        b，必须是多个线程使用同一个锁。

3.同步的利弊

        好处：解决了多线程的安全问题。

        弊端：多个线程需要判断锁，较为消耗资源。

4.如何寻找多线程中的安全问题

        a，明确哪些代码是多线程运行代码。

        b，明确共享数据。

        c，明确多线程运行代码中哪些语句是操作共享数据的。
 

四、懒汉式

懒汉式是延迟加载的，在多线程程序设计中有线程安全问题，解决方式为同步锁，同步方法的情况下，其锁为该类所属的类的二进制字节码文件对象，这样处理比较低效，应通过双重判断的方法来解决这个问题。

实现代码：

package singleDemo;
public class Single{
	private static Single s = null;
	private Single(){}
	public Single getInstance(){
		if(s == null){
			synchronized(Single.class){
				if(s==null)
					s= new Single();
			}
		}
		return s;
	}
}

五、死锁

通常出现在同步中嵌套同步的情况下，程序开发者必须避免死锁的现象。

下面是我写的死锁的代码

package exam;
public class DeathLockDemo1 
{
	public static void main(String[] args) 
	{
		Test test1= new Test(true);
		Test test2= new Test(false);
		Thread th1=new Thread(test1);
		Thread th2=new Thread(test2);
		th1.start();
		th2.start();
	}
}
class MyLock
{
	public static final Object A=new Object();
	public static final Object B=new Object();
}
class Test implements Runnable
{
	private boolean flag =false;
	private  static int num=0; 
	Test(boolean b)
	{
		this.flag = b;
	}
	public void run()
	{
		if(this.flag)
		{
			while(true)
			{        
				synchronized(MyLock.A)
				{

					System.out.println("A    true"+(num++)+"***********");
					synchronized(MyLock.B)
					{
						System.out.println("B    true"+(++num)+"***********");
					}
				}
			}
		}
		else
		{
			while(true)
			{        
				synchronized(MyLock.B)
				{
					System.out.println("B    false"+(num++)+"***********");
					synchronized(MyLock.A)
					{
						System.out.println("A    false"+(++num)+"***********");
					}
				}
			}
		}
	}
}

六、线程间通信

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

示例代码如下：

package threadExec;
class Resource {
	private String name;
	private String color;
	private boolean flag = false;
	public synchronized void setResource(String name,String color){
		if(flag){
			try{
				this.wait();
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		this.name = name;
		this.color = color;
		flag = !flag;
		this.notifyAll();
	}
	public synchronized void getResource(){
		if(!flag)
		{
			try{
				this.wait();
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.println(this.name+":"+this.color);
		flag = !flag;
		this.notifyAll();
	}
}
class Produce implements Runnable{
	private Resource res;
	private int num=0;
	public Produce(Resource res){
		this.res = res;
	}
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		while(true)
		{
			if(num%2==1)
				res.setResource("苹果", "红色");
			else
				res.setResource("香蕉", "黄");
			num=num+1;
		}
	}
}
class Consumer implements Runnable{
	private Resource res;
	public Consumer(Resource res){
		this.res = res;
	}
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		while(true)
		{
			res.getResource();
		}
	}
}
public class ThreadTrans{
	public static void main(String[] args){
		Resource res = new Resource();
		Produce pro = new Produce(res);
		Consumer con = new Consumer(res);
		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(con);
		t1.start();
		t2.start();
	}
}