mini售票系统之创建线程的三种方式

场景

学习多线程编程，写 一个mini售票系统

问题

怎么创建线程，如何模拟售票窗口

实验

模拟3个窗口卖10张票，代码如下：

/**
 * Project Name:thinkinginjava
 * File Name:ThreadCallable.java
 * Package Name:com.sourcecode.java.thread
 * Date:2016年2月14日下午10:25:25
 * Copyright (c) 2016, [email protected] All Rights Reserved.
 *
 */
package com.sourcecode.java.thread;

import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * ClassName: ThreadCallable <br/>
 * Function: TODO mini 售票系统 <br/>
 * Reason: TODO 学习有返回的线程创建方式<br/>
 * date: 2016年2月14日 下午10:25:25 <br/>
 *
 * @author Administrator
 * @version 1.0
 * @since JDK 1.6
 */
public class ThreadCallable implements Callable<Object>
{
	/*
	 * 线程数-模拟售票窗口
	 */
	public static int NUM_ThREADS = 3;

	/*
	 * 总票数
	 */
	public static int TOTAL_TICKETS = 10;

	/*
	 * 总票数
	 */
	private int ticket;

	/**
	 * Creates a new instance of ThreadCallable.
	 *
	 * @param ticket
	 *            总票数
	 */
	public ThreadCallable(int ticket)
	{
		this.ticket = ticket;
	}

	/**
	 * TODO 买票 -有返回的线程执行
	 * 
	 * @see java.util.concurrent.Callable#call()
	 */
	@Override
	public Object call() throws Exception
	{
		Date end = null;
		Date begin = new Date();
		while (true)
		{
			if (ticket > 0)
			{
				System.out.println("[Window " + Thread.currentThread().getId() + "] is sailing tiket " + ticket--);
				Thread.sleep(10);
			} else
			{
				end = new Date();
				break;
			}
		}
		long millisTotal = end.getTime() - begin.getTime();

		return TOTAL_TICKETS + " tikcets sold in " + millisTotal + " miliseconds.";
	}
	
	/**
	 * TODO 测试.<br/>
	 *
	 * @author Administrator
	 * @param args
	 * @since JDK 1.6
	 */
	public static void main(String[] args)
	{
		//构造一个固定大小的线程池
		ExecutorService poor = Executors.newFixedThreadPool(NUM_ThREADS);
		
		//执行结果封装在Future（这名字取得相当有水准啊，大赞）中：
		Future<Object> future = poor.submit(new ThreadCallable(TOTAL_TICKETS));
		try
		{
			//是滴，通过get（）就能拿到执行结果
			System.out.println(future.get().toString());
		} catch (Exception e)
		{
			System.out.println("Sorry,system busy, please try again later!");
		}
		
		//释放池资源
		poor.shutdown();
	}
}

/**
 * Project Name:thinkinginjava
 * File Name:ThreadRunnable.java
 * Package Name:com.sourcecode.java.thread
 * Date:2016年2月14日下午11:11:06
 * Copyright (c) 2016, [email protected] All Rights Reserved.
 *
 */
package com.sourcecode.java.thread;

import java.util.Date;

/**
 * ClassName: ThreadRunnable <br/>
 * Function: 模拟3个窗口共卖10张票  <br/>
 * Reason: 通过案例学习多线程3种创建方式的差异  <br/>
 * date: 2016年2月14日 下午11:11:06 <br/>
 *
 * @author Administrator
 * @version 
 * @since JDK 1.6
 */
public class ThreadRunnable
{
	/*
	 * 总票数
	 */
	public static int TOTAL_TICKETS = 10;
	
	public static void main(String[] args)
	{
		/*
		 * extends实现方式无法模拟：多线程处理同一资源（即3个窗口买10张票）
		 */
//		ThreadExtends sellerExt = new ThreadExtends(TOTAL_TICKETS);
//		Date begin = new Date();
//		sellerExt.start();
//		Date end = new Date();
//		long millisTotal = end.getTime()-begin.getTime();
//		System.out.println(TOTAL_TICKETS + " tikcets sold in " + millisTotal + " miliseconds.");
		
		//下面的做法实际上实现的是3个窗口卖 30 张票
//		ThreadExtends sellerExt1 = new ThreadExtends();
//		ThreadExtends sellerExt2 = new ThreadExtends();
//		ThreadExtends sellerExt3 = new ThreadExtends();
//		sellerExt1.start();
//		sellerExt2.start();
//		sellerExt3.start();
		
		/*
		 * implements实现方式则可以实现多窗口卖票（3个窗口买10张票）
		 */
		ThreadImplt seller = new ThreadImplt(TOTAL_TICKETS);
		Thread window1 = new Thread(seller);
		Thread window2 = new Thread(seller);
		Thread window3 = new Thread(seller);
		
		Date begin2 = new Date();
		window1.start();
		window2.start();
		window3.start();
		Date end2 = new Date();
		long millisTotal2 = end2.getTime()-begin2.getTime();
		System.out.println(TOTAL_TICKETS + " tikcets sold in " + millisTotal2 + " miliseconds.");
	}
}

class ThreadExtends extends Thread
{
	/*
	 * 总票数
	 */
	private int ticket; 
	
	/**
	 * Creates a new instance of ThreadExtends.
	 *
	 * @param ticket
	 */
	
	public ThreadExtends(int ticket)
	{
		this.ticket = ticket;
	}

	/**
	 * 
	 * TODO 执行-买票.
	 * @see java.lang.Thread#run()
	 */
	public void run()
	{
		while (true)
		{
			if (ticket > 0)
			{
				System.out.println("[Window " + Thread.currentThread().getId() + "] is sailing tiket " + ticket--);
				try
				{
					Thread.sleep(10);
				}
				catch (InterruptedException e)
				{
					//日志处理
					throw new RuntimeException(e.toString()+"errorCode");
				}
			} 
			else
			{
				break;
			}
		}
	}
}

class ThreadImplt implements Runnable
{
	/*
	 * 总票数
	 */
	private int ticket; 
	
	/**
	 * Creates a new instance of ThreadImplt.
	 *
	 * @param ticket
	 */
	
	public ThreadImplt(int ticket)
	{
		this.ticket = ticket;
	}

	/**
	 * TODO 执行-买票.
	 * @see java.lang.Runnable#run()
	 */
	@Override
	public void run()
	{
		while (true)
		{
			if (ticket > 0)
			{
				System.out.println("[Window " + Thread.currentThread().getId() + "] is sailing tiket " + ticket--);
				try
				{
					Thread.sleep(10);
				}
				catch (InterruptedException e)
				{
					//日志处理
					throw new RuntimeException(e.toString()+"errorCode");
				}
			} 
			else
			{
				break;
			}
		}
	}
}

总结

java 共两种创建线程的方式：

一、无返回类，又分为两大类即 实现Runnable接口 与 继承 Thread 类（extends Thread 实际也属于实现Runnbale接口类 - Thread本身实现了Runnbale接口）。

•  我们很多情况下要把一个类的子类放到多线程中去，这个时候就就只能 通过implement创建： java单继承
•  相同程序代码的线程去处理同一个资源。比如说，铁路售票系统的模拟。

二、有返回类，即 实现Callable接口。

参考文献

1、三种实现线程的方式 http://www.cnblogs.com/yezhenhan/archive/2012/01/09/2317636.html  感谢博主！

2、 张孝祥-Java多线程与并发库高级应用 向张老师致敬！