Java多线程

一.概念

       （1）什么是线程？

          线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持。

       （2）和进程有什么关系？        

           线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的  线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。

二.实现方式

       （1）有几种实现方式

             Java创建线程的4种方式
               1.通过Thread类，重写run方法

               2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target

               3.通过Callable和FutureTask创建线程

               4.通过线程池创建线程

              区别：

                 实现方式区别：

                      （1）Thread和Runnable可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所                   以没有办法返回结果 ；Callable/FutureTash和线程池创建可以归结成一类：有返回值，通过Callable接口，就要实现call                   方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

                    （2）Thread和Runnable不同，由于Thread属于继承，Runnable属于实现，而Java只允许有一个继承，但可以有多个                   实现，所以在使用方式还是有区别

                      (3)  Runnable的代码可以被多个线程共享（Thread实例），适合于多个多个线程处理统一资源的情况

                            举例说明：模拟卖票，假设还剩5张票，分别采用两种方式来创建线程模拟

采用继承方式模拟3个窗口卖5张票的情况

public static void main(String[] args) {
		MyThread mt1 = new MyThread("线程一");
		MyThread mt2 = new MyThread("线程二");
		MyThread mt3 = new MyThread("线程三");

		// 启动线程
		mt1.start();
		mt2.start();
		mt3.start();
	}

	static class MyThread extends Thread {
		private int num = 5; // 共有5张票
		private String name; // 线程名

		public MyThread(String name) {
			this.name = name;
		}

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while(num > 0) {
				num--;
				System.out.println(name + "卖出了一张票，剩余票数为：" + num);
			}
		}
	}

运行结果，如下：通过结果得出每个窗口卖出5张票，共计15张票 

线程一卖出了一张票，剩余票数为：4
线程一卖出了一张票，剩余票数为：3
线程一卖出了一张票，剩余票数为：2
线程一卖出了一张票，剩余票数为：1
线程一卖出了一张票，剩余票数为：0
线程二卖出了一张票，剩余票数为：4
线程三卖出了一张票，剩余票数为：4
线程二卖出了一张票，剩余票数为：3
线程三卖出了一张票，剩余票数为：3
线程二卖出了一张票，剩余票数为：2
线程三卖出了一张票，剩余票数为：2
线程三卖出了一张票，剩余票数为：1
线程三卖出了一张票，剩余票数为：0
线程二卖出了一张票，剩余票数为：1
线程二卖出了一张票，剩余票数为：0

采用Runnable实现 

	public static void main(String[] args) {
		MyRunnable mt = new MyRunnable();

		Thread mt1 = new Thread(mt, "线程一");
		Thread mt2 = new Thread(mt, "线程二");
		Thread mt3 = new Thread(mt, "线程三");

		// 启动线程
		mt1.start();
		mt2.start();
		mt3.start();
	}

	static class MyRunnable implements Runnable {
		private int num = 5; // 共有5张票

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (num > 0) {
				num--;
				System.err.println(Thread.currentThread().getName() + "卖出了一张票，剩余票数为：" + num);
			}
		}

	}

运行结果如下：

线程一卖出了一张票，剩余票数为：2
线程三卖出了一张票，剩余票数为：2
线程二卖出了一张票，剩余票数为：2
线程三卖出了一张票，剩余票数为：0
线程一卖出了一张票，剩余票数为：1

      这样可以看出多个线程共享了Runnbale里面的5这个变量，至于结果为什么不是输出剩余票数4 3 2 1 0，这个是由于线程的调度问题造成的，每次运行都会看到不一样的结果                            

线程实现方式3：通过Callable和FutureTask创建线程 
a:创建Callable接口的实现类 ，并实现Call方法 
b:创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值 
c:使用FutureTask对象作为Thread对象的target创建并启动线程 
d:调用FutureTask对象的get()来获取子线程执行结束的返回值

public class ThreadDemo03 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Callable<Object> oneCallable = new Tickets<Object>();
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);

        Thread t = new Thread(oneTask);

        System.out.println(Thread.currentThread().getName());

        t.start();

    }

}

class Tickets<Object> implements Callable<Object>{

    //重写call方法
    @Override
    public Object call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
        return null;
    }   
}

程序运行结果： 

main 
Thread-0–>我是通过实现Callable接口通过FutureTask包装器来实现的线程

线程实现方式4：通过线程池创建线程

public class ThreadDemo05{

    private static int POOL_NUM = 10;     //线程池数量

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ExecutorService executorService = Executors.newFixedThreadPool(5);  
        for(int i = 0; i<POOL_NUM; i++)  
        {  
            RunnableThread thread = new RunnableThread();

            //Thread.sleep(1000);
            executorService.execute(thread);  
        }
        //关闭线程池
        executorService.shutdown(); 
    }   

}

class RunnableThread implements Runnable  
{     
    @Override
    public void run()  
    {  
        System.out.println("通过线程池方式创建的线程：" + Thread.currentThread().getName() + " ");  

    }  
}

程序运行结果： 

通过线程池方式创建的线程：pool-1-thread-3 
通过线程池方式创建的线程：pool-1-thread-4 
通过线程池方式创建的线程：pool-1-thread-1 
通过线程池方式创建的线程：pool-1-thread-5 
通过线程池方式创建的线程：pool-1-thread-2 
通过线程池方式创建的线程：pool-1-thread-5 
通过线程池方式创建的线程：pool-1-thread-1 
通过线程池方式创建的线程：pool-1-thread-4 
通过线程池方式创建的线程：pool-1-thread-3 
通过线程池方式创建的线程：pool-1-thread-2

ExecutorService、Callable都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征，还有Future接口也是属于这个框架，有了这种特征得到返回值就很方便了。 
通过分析可以知道，他同样也是实现了Callable接口，实现了Call方法，所以有返回值。这也就是正好符合了前面所说的两种分类

执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了。get方法是阻塞的，即：线程无返回结果，get方法会一直等待。

再介绍Executors类：提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。

public static ExecutorService newFixedThreadPool(int nThreads) 
创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool() 
创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor() 
创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int 
corePoolSize) 
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。