java 多线程概要

详细内容 : http://blog.csdn.net/lonelyroamer/article/details/7948329

一、概念
1、进程和线程的概念
进程：运行中的应用程序称为进程，拥有系统资源（cpu、内存）
线程：进程中的一段代码，一个进程中可以有多段代码。本身不拥有资源（共享所在进程的资源）
在Java中，程序入口被自动创建为主线程，在主线程中可以创建多个子线程。
区别：
1、是否占有资源问题
2、创建或撤销一个进程所需要的开销比创建或撤销一个线程所需要的开销大。
3、进程为重量级组件，线程为轻量级组件
多进程: 在操作系统中能同时运行多个任务(程序)
多线程: 在同一应用程序中有多个功能流同时执行

2、多线程（多个线程同时运行）程序的主要优点
①、可以减轻系统性能方面的瓶颈，因为可以并行操作；
②、提高CPU的处理器的效率，在多线程中，通过优先级管理，可以使重要的程序优先操作，提高了任务管理的灵活性；另一方面，在多CPU系统中，可以把不同的线程在不同的CPU中执行，真正做到同时处理多任务。

二、创建线程
java中创建一个线程有两种方式：
1、继承Thread类，重写run()方法，然后直接new这个对象的实例，创建一个线程的实例。然后调用start()方法启动线程
2、实现Runnable接口，重写run()方法，然后调用new Thread(runnable)的方式创建一个线程，然后调用start()方法启动线程

继承Thread：

public class Test1 {  
    public static void main(String[] args) {  
        System.out.println(Thread.currentThread().getName());  
        MyThread myThread=new MyThread();  
        myThread.start();  
    }  
}  
class MyThread extends Thread{  
    int i=0;  
    @Override  
    public void run() {  
        while (i<10) {  
            System.out.println(this.getName()+"    i的值   "+i);  
            i++;  
        }  
    }  
}  

实现Runnable接口：

public class Test1 {  
    public static void main(String[] args) {  
        System.out.println(Thread.currentThread().getName());  
        Thread thread=new Thread(new MyRunnable());  
        thread.start();  
    }  
}  
class MyRunnable implements Runnable{  
    int i=0;  
    @Override  
    public void run() {  
        while (i<10) {  
            System.out.println(Thread.currentThread().getName()+"    i的值   "+i);  
            i++;  
        }  
    }  
}

3、两种方式的对比
采用实现Runnable接口方式的多线程具有优势，一般都会使用这种方式：
1、线程类只是实现了Runnable接口，还可以继承其他类。
2、在这种方式下，可以多个线程共享一个Runnable target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好的体现了面向对象的思想。

三、线程的生命周期：
1、生命周期：新建 就绪 运行 阻塞 死亡
2、线程的控制方法：线程睡眠——sleep、线程让步——yield、线程合并——join ……
3、结束一个线程：正常执行完run方法，然后结束掉；控制循环条件和判断条件的标识符来结束掉线程；使用interrupt结束一个线程

四、线程同步
1、同步互斥锁：并发执行的多个线程在某一时间内只允许一个线程在执行以访问共享数据。
①、取得同步锁的对象为this，即当前类对象，这是使用的最多的一种方式

public void show() {  
    synchronized(this){  
       ......  
    }  
}  

②、将synchronized加到方法上，这叫做同步方法

public synchronized void show() {  

}  

③、静态方法的同步

public static synchronized void show() {  

}  

synchronized关键字使用要注意以下几点：
1）、只能同步方法和代码块，而不能同步变量和类。
2）、每个对象只有一个同步锁；
3）、线程睡眠时，它所持的任何同步锁都不会释放。

五、死锁
六、线程的协调运行：生产者和消费者
wait、notify和notifyAll三个方法一定是在同步代码块中使用

七、线程池
JDK1.5中提供Executors工厂类来产生连接池，使用线程池可以很好的提供性能。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  

public class PoolTest {  
    public static void main(String[] args) {  
        ExecutorService pool=Executors.newFixedThreadPool(5);//创建一个固定大小为5的线程池  
        for(int i=0;i<7;i++){  
            pool.submit(new MyThread());  
        }  
        pool.shutdown();  
    }  
}  
class MyThread extends Thread{  
    @Override  
    public void run() {  
            System.out.println(Thread.currentThread().getName()+"正在执行。。。");  
    }  
}  

八、Callable和Future
1、可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。

public class Test { 
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
                //创建一个线程池 
                ExecutorService pool = Executors.newFixedThreadPool(2); 
                //创建两个有返回值的任务 
                Callable c1 = new MyCallable("A"); 
                Callable c2 = new MyCallable("B"); 
                //执行任务并获取Future对象 
                Future f1 = pool.submit(c1); 
                Future f2 = pool.submit(c2); 
                //从Future对象上获取任务的返回值，并输出到控制台 
                System.out.println(">>>"+f1.get().toString()); 
                System.out.println(">>>"+f2.get().toString()); 
                //关闭线程池 
                pool.shutdown(); 
        } 
} 

class MyCallable implements Callable{ 
        private String oid; 

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

        @Override 
        public Object call() throws Exception { 
                return oid+"任务返回的内容"; 
        } 
}

九、volatile关键字
1、Java包含两种内在的同步机制：同步块（或方法）和 volatile 变量，都是为了实现代码线程的安全性
2、 volatile 的使用条件 —— 即变量真正独立于其他变量和自己以前的值
3、Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。

十、ThreadLocal类(线程局部变量)
1、为每一个使用该变量的线程都提供一个变量值的副本，一种隔离机制
2、ThreadLocalMap实际上就是个Map，它是以当前ThreadLcoal实例为key来存储。
3、Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。