JAVA学习第二十三课（多线程（二））- （多线程的创建方式二：实现Runnable接口（常用））

时间：2014-10-09 23:47:18 阅读：319 评论：0 收藏：0 [点我收藏+]

标签：style blog http color io ar java for strong

当一个类有父亲，但是其中的功能还希望实现线程,那么就不能采用继承Thread的方式创建线程
那么就可以通过接口的方式完成

准备扩展Demo类的功能，让其中的内容可以作为线程的任务执行
实现Runnable接口，Runnable接口中只有一个方法run

一、创建线程的第二种方法

Runnable的出现仅仅是将线程的任务进行了对象的封装

/*
* 创建线程的第二种方法
* 1.定义类实现Runnable接口
* 2.覆盖接口中的fun方法，将线程的任务代码封装到run方法中
* 3.通过Thread类创建线程对象，并将Runnable接口的子类对象作为构造函数的参数进行传递
* 为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中，所以要在线程对象创建
* 时就要明确要运行的任务
* 4.调用线程的start方法开启线程

class Demo implements Runnable
{
	public void run()
	{
		show();
	}
	public void show()
	{
		for(int i = 0;i<10;i++)
		{
			System.out.println(Thread.currentThread().getName()+"i = "+i);
		}
	}
}
public class Main
{
	public static void main(String[] args)
	{
		//定义线程的方式
		Demo jo = new Demo();
		//Thread中有一个Thread（Runnable t）的方法
		Thread aThread = new Thread(jo);
		//如果不传递，start只会执行自己的方法
		Thread bThread = new Thread(jo);
		aThread.start();
		bThread.start();
	}
}

二、实现Runnable接口和继承Thread类的区别

实现Runnable接口的好处：

1.将线程的任务同线程的子类中分离出来，进行了单独的封装，也就是将任务封装成了对象

2.避免了单继承的局限性

所以，创建线程的第二种方式较为常用。

三、代码实例：

第一种线程的创建方式

/*
 * 需求：4个窗口进行买票，票数100张，编号1-100
 * 
 */
class Ticket extends Thread
{
	private int num = 100;
	//private static int num = 100;
	public void run()
	{
		while(true)
		{
			if(num>0)
			{
				System.out.println(Thread.currentThread().getName()+"..sale.."+num--);	
			}	
		}
	}
}
public class Main 
{
	public static void main(String[] args)
	{
		Ticket j1 = new Ticket();
		Ticket j2 = new Ticket();
		Ticket j3 = new Ticket();
		Ticket j4 = new Ticket();
		j1.start(); j2.start(); 
		j3.start(); j4.start();
	}
}

PS:用第一种方式创建线程，可能出现有多个窗口卖同一号票的情况（1号窗口卖10号票，3号窗口也卖10号票）当然可以将票定义为静态的，但是仅限于是一种票，如果多种票就不适用了

第二种创建线程的方式

/*
 * 需求：4个窗口进行买票，票数100张，编号1-100
 * 
 */
class Ticket implements Runnable
{
	private int num = 100;
	//private static int num = 100;
	public void run()
	{
		while(true)
		{
			if(num>0)
			{
				System.out.println(Thread.currentThread().getName()+"..sale.."+num--);	
			}	
		}
	}
}
public class Main 
{
	public static void main(String[] args)
	{
		/*
		Ticket t = new Ticket();//将 卖票这一行为封装成对象
		Thread j1 = new Thread(t);
		Thread j2 = new Thread(t);
		Thread j3 = new Thread(t);
		Thread j4 = new Thread(t);
		j1.start(); j2.start(); 
		j3.start(); j4.start();
		*/
		//两种票，站票、坐票
		Ticket zhanpiao = new Ticket();
		Ticket zuopiao = new Ticket();
		//1 2窗口卖站票，3 4 窗口卖坐票
		Thread j1 = new Thread(zhanpiao);
		Thread j2 = new Thread(zhanpiao);
		Thread j3 = new Thread(zuopiao);
		Thread j4 = new Thread(zuopiao);
		j1.start(); j2.start(); 
		j3.start(); j4.start();
	}
}

四、线程的安全问题

public void run()
	{
		while(true)
		{
			if(num>0)
			{
				System.out.println(Thread.currentThread().getName()+"..sale.."+num--);	
			}	
		}
	}

这段代码是存在安全隐患的，理想状态下不会出现卖0号票的可能，但是一旦出现，进程就会出事

class Ticket implements Runnable
{
	private int num = 100;
	//private static int num = 100;
	public void run()//此处不能throws，因为Runnable没有声明异常 
	{
		while(true)
		{
			if(num>0)
			{
				//睡10毫秒，sleep可能存在异常
				//所以只能try，catch，不能抛
				try 
				{
					Thread.sleep(10);
				} 
				catch (InterruptedException e) 
				{
					// TODO: handle exception
				}
				
				System.out.println(Thread.currentThread().getName()+"..sale.."+num--);	
			}	
		}
	}
}
public class Main 
{
	public static void main(String[] args)
	{
		Ticket t = new Ticket();
		Thread j1 = new Thread(t);
		Thread j2 = new Thread(t);
		Thread j3 = new Thread(t);
		Thread j4 = new Thread(t);
		j1.start(); j2.start(); 
		j3.start(); j4.start();
	

	}
}