java线程总结

一、进程和线程的比较

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。进程的特点，每一个进程都有自己的独立的一块内存空间、一组资源系统。其内部数据和状态都是完全独立的。

线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈)，同类的多个线程共享一块内存空间和一组系统资源，线程本身的数据通常只有CPU的寄存器数据，以及一个供程序执行时的堆栈。一个进程中可以包含多个线程。

1.1 进程线程的区别

地址空间：线程是进程内的一个执行单元；进程至少有一个线程；同类线程共享进程的地址空间；而进程有自己独立的地址空间

资源拥有：进程是资源分配和拥有的单位，同一个进程内的线程共享进程的资源

线程是处理器调度的基本单位，但进程不是

二者均可并发执行

注：关于并发与并行

 并发：多个事件在同一时间段内一起执行

 并行：多个事件在同一时刻同时执行

1.2 多任务和多线程

多任务

在一开始，一个计算机只有一个CPU，这个CPU一次也只能运行一个任务。然而随着计算机技术的发展，一个CPU也可以“同时”运行多个任务，这就诞生了多任务。但这里的同时并不是真正的同时，操作系统通过切换各个应用来实现CPU的共享，在CPU内部各个程序其实是交替执行的。

多线程

为了进一步提高CPU利用率，多线程便诞生了。一个程序中可以运行多个线程，多个线程可以同时执行，从整个应用角度上看，这个应用好像独自拥有多个CPU一样。虽然多线程进一步提高了应用的执行效率，但是由于线程之间会共享内存资源，这也会导致一些资源同步问题，另外，线程之间的切换也会对资源有所消耗

多线程的调度

在Java程序中，JVM负责线程的调度。线程调度是指按照特定的机制为多个线程分配CPU的使用权。

调度的模式有两种：分时调度和抢占式调度。分时调度是所有线程轮流获得CPU使用权，并平均分配每个线程占用CPU的时间；抢占式调度是根据线程的优先级别来获取CPU的使用权。JVM的线程调度模式采用了抢占式模式。

二、线程的实现

Java中实现多线程，一种是继承Thread类，一种是实现Runable接口，还有一种不常见的创建方式是使用ExecutorService、Callable、Future实现有返回结果的多线程。

2.1 继承Thread类

/** 
 * 继承Thread类,直接调用run方法 
 * */  
class MyThread extends Thread {  
public MyThread(String name) {  
    this.name = name;  
}  
public void run() {  
    for (int i = 0; i < 5; i++) {  
        System.out.println(name + "运行     " + i);  
    }  
}  
public static void main(String[] args) {  
    hello h1=new hello("A");  
    hello h2=new hello("B");  
    h1.start();  
    h2.start();  
}  

2.2 实现Runable接口

public class TestRunnable implements Runnable{  
   private int count =100;  
   public void run(){  
         for(int i=0;i<200;i++){  
               if(count >0){  
                    System. out.println(Thread.currentThread().getName()+ " "+count --);  
              }  
        }  
  }  
   public static void main(String[] args) {  
        TestRunnable r= new TestRunnable();  
        Thread t1= new Thread(r,"A" );  
        Thread t2= new Thread(r,"B" );  
        t1.start();  
        t2.start();         
  } 

两者区别

实现Runnable接口比继承Thread类有更多的优势，所以我推荐大家尽量使用实现runnable接口的形式，以下是其优点

有关线程的两种实现方式，以及区别与优势可参见：http://blog.csdn.net/wd916913/article/details/6954317

该博客中举了个买票的例子，很形象的描绘了两种方式的区别。下面是实现Runnable接口比继承Thread类的优势

a)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。

b)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。

c)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

2.3 使用ExecutorService、Callable、Future实现有返回结果的多线程

返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了。

可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面看一个完整的例子：

/**  
* 有返回值的线程  
*/    
public class Test {    
public static void main(String[] args) throws ExecutionException,    
    InterruptedException {    
   System.out.println("----程序开始运行----");    
   Date date1 = new Date();    
    
   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);    
    // System.out.println(">>>" + f.get().toString());    
    list.add(f);    
   }    
   // 关闭线程池    
   pool.shutdown();    
    
   // 获取所有并发任务的运行结果    
   for (Future f : list) {    
    // 从Future对象上获取任务的返回值，并输出到控制台    
    System.out.println(">>>" + f.get().toString());    
   }    
    
   Date date2 = new Date();    
   System.out.println("----程序结束运行----，程序运行时间【"    
     + (date2.getTime() - date1.getTime()) + "毫秒】");    
}    
}    
    
class MyCallable implements Callable<Object> {    
private String taskNum;    
    
MyCallable(String taskNum) {    
   this.taskNum = taskNum;    
}    
    
public Object call() throws Exception {    
   System.out.println(">>>" + taskNum + "任务启动");    
   Date dateTmp1 = new Date();    
   Thread.sleep(1000);    
   Date dateTmp2 = new Date();    
   long time = dateTmp2.getTime() - dateTmp1.getTime();    
   System.out.println(">>>" + taskNum + "任务终止");    
   return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";    
}    
}    

三、线程的状态

线程一共有五种状态，分别是：

1. 新建状态（New）：新创建了一个线程对象。

2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。

4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

四、线程的同步与死锁

线程同步问题，当各个线程共用一个资源时，有可能导致线程同步问题。在JAVA中，是没有类似于PV操作、进程互斥等相关的方法的。JAVA的线程同步是通过synchronized()来实现的，需要说明的是，JAVA的synchronized()方法类似于操作系统概念中的互斥内存块，在JAVA中的Object类型中，都是带有一个内存锁的，在有线程获取该内存锁后，其它线程无法访问该内存，从而实现JAVA中简单的同步、互斥操作。

1）线程同步，一个关键字：synchronized

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

 a) 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

b) 然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

c) 尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

d) 第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

e) 以上规则对其它对象锁同样适用.

具体请参见我的博客：http://blog.csdn.net/gjnm820/article/details/51034254

2) 线程死锁

假如有2个线程，一个线程想先锁对象1，再锁对象2，恰好另外有一个线程先锁对象2，再锁对象1。在这个过程中，当线程1把对象1锁好以后，就想去锁对象2，但是不巧，线程2已经把对象2锁上了，也正在尝试去锁对象1。什么时候结束呢，只有线程1把2个对象都锁上并把方法执行完，并且线程2把2个对象也都锁上并且把方法执行完毕，那么就结束了，但是，谁都不肯放掉已经锁上的对象，所以就没有结果，这种情况就叫做线程死锁。

其中一个解决方法就是加大锁定的粒度，也就是尽量锁大的对象，不要锁得太小，还有尽量不要同时锁2个或2个以上的对象，但是还有待于进一步研究。

 

参考文章：

http://blog.csdn.net/suifeng3051/article/details/49251959

http://blog.csdn.net/aboy123/article/details/38307539

http://blog.csdn.net/superhill/article/details/7526771