谈谈java线程基础

1. 操作系统中线程和进程的概念

现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在windows系统中，一个运行的exe就是一个进程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。

在java中要想实现多线程，有两种手段，一种是继承Thread类，另一种是实现Runable接口(其实准确来讲，应该有三中的，还有一种是实现Callable接口，并与Future、线程池结合使用)

2. java线程的实现形式

这里继承Thread类的方式是比较常用的一种，如果说你只是想起一条线程。没有什么其他特殊的要求，那么可以使用Thread

3.继承Thread类

/** 
 * 测试扩展Thread类实现的多线程程序 
 */  
public class TestThread extends Thread {  
    public TestThread(String name){  
       super(name);  
    }  
    @Override  
    public void run() {  
       for(int i=0;i<5;i++){  
           for(long k=0;k<100000000;k++);  
           System.out.println(this.getName()+":"+i);  
       }  
    }  
    public static void main(String[] args){  
       Thread t1=new TestThread("李白");  
       Thread t2=new TestThread("张飞");  
       t1.start();  
       t2.start();        
    }  
}

执行结果:
张飞:0
李白:0
张飞:1
李白:1
张飞:2
李白:2
张飞:3
张飞:4
李白:3
李白:4

4.实现Runnable接口

public class RunnableImpl implements Runnable{  
    private String name;  
    public RunnableImpl(String name) {  
       this.name = name;  
    }  
    @Override  
    public void run() {  
       for (int i = 0; i < 5; i++) {  
           for(long k=0;k<100000000;k++);  
           System.out.println(name+":"+i);  
       }       
    }  
}  
   
/** 
 * 测试Runnable类实现的多线程程序 
 */  
class TestRunnable {  
   
    public static void main(String[] args) {  
       RunnableImpl ri1=new RunnableImpl("李白");  
       RunnableImpl ri2=new RunnableImpl("张飞");  
       Thread t1=new Thread(ri1);  
       Thread t2=new Thread(ri2);  
       t1.start();  
       t2.start();  
    }  
}

执行结果:
李白:0
张飞:0
张飞:1
李白:1
张飞:2
李白:2
张飞:3
李白:3
张飞:4
李白:4

说明： Thread2类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

5.使用Callable和Future接口创建线程

具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

public class ThreadTest {
 
     public static void main(String[] args) {
 
         Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
         FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象
 
        for (int i = 0; i < 100; i++) {
             System.out.println(Thread.currentThread().getName() + " " + i);
             if (i == 30) {
                 Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
                 thread.start();                      //线程进入到就绪状态
             }
         }
 
         System.out.println("主线程for循环执行完毕..");
         
         try {
             int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
             System.out.println("sum = " + sum);
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }
 }
 
 
 class MyCallable implements Callable<Integer> {
   private int i = 0;
 
     // 与run()方法不同的是，call()方法具有返回值
     @Override
     public Integer call() {
       int sum = 0;
         for (; i < 100; i++) {
             System.out.println(Thread.currentThread().getName() + " " + i);
             sum += i;
         }
         return sum;
 }

执行结果:
main 0
main 1
main 2
main 3
...省略
main 99
主线程for循环执行完毕..
Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
...省略
Thread-0 99
sum = 4950

首先，我们发现，在实现Callable接口中，此时不再是run()方法了，而是call()方法，此call()方法作为线程执行体，同时还具有返回值！在创建新的线程时，是通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target。那么看下FutureTask类的定义：

public class FutureTask<V> implements RunnableFuture<V> {
         //....
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
         void run();
 }

于是，我们发现FutureTask类实际上是同时实现了Runnable和Future接口，由此才使得其具有Future和Runnable双重特性。通过Runnable特性，可以作为Thread对象的target，而Future特性，使得其可以取得新创建线程中的call()方法的返回值。

执行下此程序，我们发现sum = 4950永远都是最后输出的。而“主线程for循环执行完毕..”则很可能是在子线程循环中间输出。由CPU的线程调度机制，我们知道，“主线程for循环执行完毕..”的输出时机是没有任何问题的，那么为什么sum =4950会永远最后输出呢？

原因在于通过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。

main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。