Java多线程

线程

单线程的程序只包含一个顺序执行流；多线程程序可以包含多个顺序执行流，且多个顺序执行流之间互不干扰。单线程的程序如同只雇佣一个服务员的餐厅，他必须做完一件事情才可以去做下一件事情；多线程的程序则如同雇佣了多个服务员的餐厅，他们可以同时进行着多件事情。

一个进程可包含多个线程；多线程之间共享此进程锁分配到的内存。

线程的创建和启动

一、继承Thread创建线程类

1、定义Thread类的子类，并重写该类的run方法，该run方法的方法体就是代表了线程需要完成的任务。因此，我们经常把run方法称为线程执行体。

2、创建Thread子类的实例。

3、用线程对象的start方法来启动该线程。

package threads;

public class threadtest extends Thread{
	private int i;
	public void run(){
		for(;i<100;i++){
			System.out.println(getName()+" "+i);
		}
	}
	
	public static void main(String args[]){
		for(int i=0;i<100;i++){
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==20){
				new threadtest().start();
				new threadtest().start();
			}
		}
	}
}

通过运行上面程序，发现两个线程的i互相不连续；即使用继承Thread类的方法来创建线程类，多条线程之间无法共享线程类的实例变量。

二、实现Runnable接口创建线程类

1、定义Runnable接口的实现类，并重写该接口的run（）方法，该run（）方法体同样是该线程的线程执行体

2、创建Runnable实现类的实例，并以此实例作为Thread的Target来创建Thread对象，该Thread对象才是真正的线程对象。

3、调用线程对象的start方法来启动该线程。

package threads;

public class ThreadSecond implements Runnable{
	private int i;
	public void run(){
		for(;i<100;i++){
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
	
	public static void main(String args[]){
		for(int i=0;i<100;i++){
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==20){
				ThreadSecond ts=new ThreadSecond();
				new Thread(ts,"线程1").start();
				new Thread(ts,"线程2").start();
			}
		}
	}
}

运行上面程序发现，两条子线程的i是连续的；即采用Runnable接口的方式创建的多线程可以共享线程体的实例属性。这是因为在这种方式下，程序所创建的Runnable对象只是线程的target，而多条线程可以共享一个target，故可共享一个target的属性。

两种方式创建线程的对比

采用Thread类实现的多线程：

线程已经继承了Thread类，不可继承其他类；编写简单，访问当前线程，只需用this。

采用Runnable接口实现的多线程：

可以继承其他类；编写复杂，访问当前线程，需要Thread.getCurrentThread()方法。

可以多线程共享一个target对象，非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好的体现了面向对象的特性

线程的生命周期

线程被创建并启动后，并不是一启动就进入执行状态，也不是一直处于执行状态；线程启动后并不能一直占用CPU独自运行，CPU会在多条线程之间切换，所以线程也会多次在运行、阻塞之间切换。线程的生命周期有五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）。

当线程创建（new）后，Java虚拟机为其分配了内存，并初始化成员变量的值；

当线程对象调用start（）方法后，线程处于就绪状态，Java虚拟机为其创建方法调用栈和程序计数器，等待JVM线程调度器为其调度；

如果就绪状态的线程获得了CPU，开始执行run（）方法的程序体，则该线程处于运行状态，如果计算机只有一个CPU，在任何时候只有一条线程处于运行状态。当然多处理器的计算机可以有多个线程并行执行。

当发生如下情况时，线程进入阻塞状态：

线程调用sleep方法主动放弃占用CPU资源；

线程调用一个阻塞式IO方法，该方法返回之前，该线程被阻塞；

线程视图获得一个同步监视器，但该同步监视器正被其他线程持有；

线程在等待某个通知（notify）；

程序调用了线程的suspend方法将该线程挂起。（易导致死锁）

特例：调用yield（）方法可以让当前处于运行状态的线程转入就绪状态

从阻塞进入就绪状态。线程进入阻塞后，其他线程就有机会获得执行了，在特定情况下解除阻塞，线程重新进入就绪状态：

调用sleep方法的线程经过了指定时间；

线程调用的阻塞式IO方法已经返回

线程成功获得同步监视器；

线程正在等待某个通知时，其他线程发出了一个通知；

处于suspend状态的线程被调用了resume方法

当发生以下情况时，线程死亡

run（）方法执行完成，线程正常结束；

线程抛出一个未捕获的Exception或Error

直接调用该线程的stop（）方法来结束该线程（易导致死锁）

控制线程

一、join线程

Thread提供了一个线程等待另一个线程完成的方法：join（）方法。当在线程A执行流中调用线程B的join（）方法时，线程A将被阻塞，直到被join方法加入的join线程B完成为止。

package threads;

public class JoinThread extends Thread{
	//提供一个带参数的构造器，设置线程名称
	public JoinThread(String name){
		super(name);
	}
	public void run(){
		for(int i=0;i<100;i++){
			System.out.println(getName()+" "+i);
		}
	}
	//main主线程
	public static void main(String args[]) throws InterruptedException{
		//启动子线程
		new JoinThread("新线程").start();
		for(int i=0;i<100;i++){
			if(i==20){
				JoinThread jt=new JoinThread("被Join进来的线程");
				jt.start();
				//main线程调用了jt线程的join方法，main线程必须等jt执行结束才会向下执行
				jt.join();
			}
			System.out.println(Thread.currentThread().getName()+" "+i);
			
		}
	}
}

上面程序中共有3个线程，主方法一开始就开启了“新线程”这个子线程，它将和main主线程并发执行。当主线程的循环变量i等于20时，启动了名为“被join进来的线程”的线程，该线程不会和main线程并发执行，而是main线程必须 等该线程执行完后才可以向下执行。在“被join进来的线程”这个线程执行时，其实只有两个子线程并发执行，主线程处于等待状态。

Join（）方法的重载形式：

join（）：等待被join的线程执行完成

join（long millis）：等待被join的线程的时间最长为millis毫秒，若millis时间内被join的线程还没执行结束则不再等待

二、后台线程：

有一种线程是在后台运行的，它的任务是为其他线程提供服务，这种线程被称为“后台线程”。JVM的垃圾回收线程就是典型的后台线程。

特点：如果前台线程都死亡，后台线程会自动死亡。

三、线程睡眠：sleep

我们需要让正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep方法，sleep方法有两种重载形式：

static void sleep（long millis）：让当前执行的线程暂停millis秒，并进入阻塞状态。

static void sleep（long millis，int nanos）：让当前执行的线程暂停millis毫秒加nanos微秒，并进入阻塞状态。

线程在Sleep时间段内不会获得执行的机会，即使线程中没有其他可运行的线程，处于sleep中的线程也不会执行，因此sleep方法常用来暂停程序的执行。

package threads;

import java.util.Date;

public class TestThread{
	public static void main(String args[]) throws InterruptedException{
		for(int i=0;i<10;i++){
			System.out.println("当前时间："+new Date());
			Thread.sleep(1000);
		}
	}
}

上面程序输出的10条字符串的间隔将为1秒

四、线程让步：yield

我们需要让正在执行的线程暂停一段时间，并进入就绪状态，则可以通过调用Thread类的静态yield方法。其作用是线程暂停，让线程调度器重新调度一次，有可能暂停后线程调度器又马上重新将其调度来重新执行。

package threads;

public class TestYield extends Thread{
	public TestYield(){
	}
	public TestYield(String name){
		super(name);
	}
	
	public void run(){
		for(int i=0;i<50;i++){
			System.out.println(getName()+" "+i);
			if(i==20){
				Thread.yield();
			}
		}
	}
	
	public static void main(String agrs[]){
		TestYield ty1=new TestYield("高级");
		//ty1.setPriority(Thread.MAX_PRIORITY);
		ty1.start();
		TestYield ty2=new TestYield("低级");
		//ty2.setPriority(Thread.MIN_PRIORITY);
		ty2.start();
	}
}

sleep方法比yield方法具有更好的可移植性，通常不适用yield来控制并发线程的执行。

五、改变线程的优先级

Thread提供了setPriority(int priority)和getPriority()来设置和获得线程的优先级，其中setPriority的参数可以是一个1~10的整数，也可以是Thread的三个静态常量：

MAX_PRIORITY:10   MIN_PRIORITY:1    NORM_PRIORITY:5

优先级数值越高，线程的优先级越高

线程的同步

如果多个线程访问同一个变量，并保持数据的完整性，往往会用到同步监视器，以保证在认识时候只有一个线程访问变量；没有结果前，调用就不会返回，其他线程也不能调用。

一、用同步代码块实现同步

使用同步监视器的通用方法就是同步代码块。

Synchronized(obj){
   ....
}

其中obj是被锁定的资源（obj也被称为 同步监视器），期间其他线程无法访问此资源。代码块结束后，自动解锁。

二、用同步方法实现同步

Java还提供了对方法的同步，即用Synchronized关键字来修饰某个方法，则该方法称为同步方法。同步方法中无需显式指定同步监视器，同步方法的同步监视器是this，即对象本身。

public synchronized void add(){
   ...
}
 

通过方法的同步，可以讲某类变为线程安全的类：该类的对象可以被多个线程访问，并安全。

方法同步后，方法所在的对象将被一条线程锁定，从而保证对象的安全。建议只对会改变竞争资源的方法同步，不要对所有方法同步，否则将降低效率。

Synchronized可修饰代码块、方法；不能修饰构造器、属性等。

三、用锁实现同步

除了同步代码块及方法实现同步外，java还提供了Lock（锁）来实现同步。使用Lock可以显式加锁、解锁。常用的锁有ReentrantLock（可重入锁）等。

class locktest{
    private final ReentrantLock lock=new ReentrantLock();
    public void a(){
      lock.lock();
      try{}
      finally{
        lock.unlock();
      }
    }
}

四、死锁

两个线程互相等待对方释放共享资源时就会发生死锁。多线程编程时，应该采取措施避免死锁的出现。系统中有多个共享资源时，容易发生死锁。Thread类的suspend方法易导致死锁，不推荐使用。

五、用volatile关键字修饰变量

用在多线程，同步变量。 线程为了提高效率，将某成员变量(如A)拷贝了一份（如B），线程中对A的访问其实访问的是B。只在某些动作时才进行A和B的同步。因此存在A和B不一致的情况。volatile就是用来避免这种情况的。volatile告诉jvm， 它所修饰的变量不保留拷贝，直接访问主内存中的（也就是上面说的A) 

volatile关键字相信了解Java多线程的读者都很清楚它的作用。volatile关键字用于声明简单类型变量，如int、float、 boolean等数据类型。如果这些简单数据类型声明为volatile，对它们的操作就会变成原子级别的。但这有一定的限制。例如，下面的例子中的n就不是原子级别的： 

package  mythread;

public   class  JoinThread  extends  Thread
{
     public   static volatile int  n  =   0 ;
    public   void  run()
    {
         for  ( int  i  =   0 ; i  <   10 ; i ++ )
             try 
        {
                n  =  n  +   1 ;
                sleep( 3 );  //  为了使运行结果更随机，延迟3毫秒 

            }
             catch  (Exception e)
            {
            }
    }

     public   static   void  main(String[] args)  throws  Exception
    {

        Thread threads[]  =   new  Thread[ 100 ];
         for  ( int  i  =   0 ; i  <  threads.length; i ++ )
             //  建立100个线程 
            threads[i]  =   new  JoinThread();
         for  ( int  i  =   0 ; i  <  threads.length; i ++ )
             //  运行刚才建立的100个线程 
            threads[i].start();
         for  ( int  i  =   0 ; i  <  threads.length; i ++ )
             //  100个线程都执行完后继续 
            threads[i].join();
        System.out.println( " n= "   +  JoinThread.n);
    }
} 

如果对n的操作是原子级别的，最后输出的结果应该为n=1000，而在执行上面积代码时，很多时侯输出的n都小于1000，这说明n=n+1不是原子级别的操作。原因是声明为volatile的简单变量如果当前值由该变量以前的值相关，那么volatile关键字不起作用，也就是说如下的表达式都不是原子操作： 

n  =  n  +   1 ; 
n ++ ; 

      如果要想使这种情况变成原子操作，需要使用synchronized关键字。

恐怕比较一下volatile和synchronized的不同是最容易解释清楚的。volatile是变量修饰符，而synchronized则作用于一段代码或方法；看如下三句get代码： 

int i1;             
int geti1() {return i1;} 
volatile int i2; 
int geti2()
{return i2;} 
int i3;              
synchronized int geti3() {return i3;} 

得到存储在当前线程中i1的数值。多个线程有多个i1变量拷贝，而且这些i1之间可以互不相同。换句话说，另一个线程可能已经改变了它线程内的i1值，而这个值可以和当前线程中的i1值不相同。事实上，Java有个思想叫“主”内存区域，这里存放了变量目前的“准确值”。每个线程可以有它自己的变量拷贝，而这个变量拷贝值可以和“主”内存区域里存放的不同。因此实际上存在一种可能：“主”内存区域里的i1值是1，线程1里的i1值是2，线程2里的i1值是3——这在线程1和线程2都改变了它们各自的i1值，而且这个改变还没来得及传递给“主”内存区域或其他线程时就会发生。 
　　而 geti2()得到的是“主”内存区域的i2数值。用volatile修饰后的变量不允许有不同于“主”内存区域的变量拷贝。换句话说，一个变量经 volatile修饰后在所有线程中必须是同步的；任何线程中改变了它的值，所有其他线程立即获取到了相同的值。理所当然的，volatile修饰的变量存取时比一般变量消耗的资源要多一点，因为线程有它自己的变量拷贝更为高效。 
　　既然volatile关键字已经实现了线程间数据同步，又要 synchronized干什么呢？呵呵，它们之间有两点不同。首先，synchronized获得并释放监视器——如果两个线程使用了同一个对象锁，监视器能强制保证代码块同时只被一个线程所执行——这是众所周知的事实。但是，synchronized也同步内存：事实上，synchronized在“ 主”内存区域同步整个线程的内存。因此，执行geti3()方法做了如下几步： 
1. 线程请求获得监视this对象的对象锁（假设未被锁，否则线程等待直到锁释放） 
2. 线程内存的数据被消除，从“主”内存区域中读入（Java虚拟机能优化此步。。。[后面的不知道怎么表达,汗]） 
3. 代码块被执行 
4. 对于变量的任何改变现在可以安全地写到“主”内存区域中（不过geti3()方法不会改变变量值） 
5. 线程释放监视this对象的对象锁 
　　因此volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。 

六、用java.util.concurrent.atomic包

Java5增加java.util.concurrent.atomic包来进行基本数据类型的同步。我们知道volatile修饰的变量可以实现基本的加载和赋值的原子性,但是对于像i++等操作就不能保证原子性了,在JDK1.5之前我们只能通过synchronized(阻塞的方式)实现这些复合操作的原子性,在JDK1.5中java.util.concurrent.atomic 包提供了若干个类能实现对int,long,boolean,reference的几个特殊方法非阻塞原子性,这一系列类的主要基于以下两点 

1.volatile修饰变量,保证get()/set()的原子性 
2.利用系统底层的CAS原语来实现非阻塞的其它方法原子操作 
  compareAndSwap(memorylocation,expectedValue,newValue);该操作接受一个预计值和新的赋值,当预计值与实际值相符合时,就表明该变量在此期间没有被别的线程改变(可能有ABA问题),就把新值赋给该引用. 
  通常将 CAS 用于同步的方式是从地址 V 读取值 A，执行多步计算来获得新值 B，然后使用 CAS 将 V 的值从 A 改为 B。如果 V 处的值尚未同时更改，则 CAS 操作成功 

1.AtomicInteger 
  实现了对Int的各种操作的原子化,我们看看其中的方法 
    
   //实现atomic类的最大诀窍##### 
    public final boolean compareAndSet(int expect, int update) { 
        //如果内存位置的值与期望值相同则,赋予新值,并返回true 
return unsafe.compareAndSwapInt(this, valueOffset, expect, update); 
    } 

   //该方法实现了i++的非阻塞的原子操作 
   public final int getAndIncrement() { 
        for (;;) { //循环,使用CAS的经典方式,这是实现non-blocking方式的代价 
            int current = get();//得到现在的值 
            int next = current + 1;//通过计算得到要赋予的新值 
            if (compareAndSet(current, next)) //关键点,调用CAS原子更新, 
                return current; 
        } 
    } 

   

2.AtmoicLong 
  与AtomicInteger相似,只是是基于Long 

3.AtmoicBoolean 
  与AtomimcInteger相似,基于boolean 
4.AtomicReference 
  与上述三个类不同,该类是用于原子地更新某个引用,只提供操作保证某个引用的更新会被原子化,常用封装某个引用会被多个线程频繁更新的场景,保证线程安全性 

public final V getAndSet(V newValue) { 
        while (true) { 
            V x = get(); 
            if (compareAndSet(x, newValue)) 
                return x; 
        } 
    } 


====================================================================== 

5.AtomicIntegerArray 
  对数组中的制定int提供几种特定的原子操作,注意不是对这个数组对象进行原子操作 
    //对数组的第i个元素进行原子的i--操作 
    //注意该类的原子操作都是针对数组中的某个指定元素的 
     public final int getAndDecrement(int i) { 
        while (true) { 
            int current = get(i); 
            int next = current - 1; 
            if (compareAndSet(i, current, next)) 
                return current; 
        } 
    } 

6.AtomicLongArray 
  与AtomicIntegerArray相似,基于long的 
7.AtomicReferenceArray 
  与AtomicIntegerArray相似,基于reference的 
====================================================================== 
8.AtomicLongFieldUpdater 
  上述的7个类都是基于对类自身的volatile数据提供原子操作,但是如何对已经存在的类中的volatile数据提供原子支持呢,这个需求是很常见的,因为我们在日常开发中经常要使用第三方的class.8#9#10这三个类就是利用反射机制对指定类的指定的volatile field提供原子操作的工具类.这三个类在原子数据结构中被用到,可以参考源码.注意只对publie volatile的非static 成员起作用 
//工厂方法,给指定类的指定fild(必须是long)建立一个update,field必须是volatile的 
public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) 

9.AtomicIntegerFieldUpdater 
与上述类相似,只是基于int 
10.AtomicReferenceFieldUpdater 
  基于Reference 
====================================================================== 
11.AtomicMarkableReference 
12.AtomicStampedReference

线程的通信

线程在系统内运行时，程序通常无法准确控制线程的轮换执行，但我们可以通过一些机制保证线程协调运行。

假设现在系统中有两个线程，分别代表存款者和取款者，要求存款者和取款者不断地重复存款、取钱的动作；且要求每当存款者将钱存入银行，取款者马上将钱取出；不允许连续两次存钱，也不允许取钱者连续两次取钱。

若实现以上功能，可以借助Object类提供的wait（）、notify（）、notifyAll（）三个方法，三个方法不属于Thread类，而是属于Object类。但三个方法必须由同步监视器来调用，这可分为两种情况：

一、对于使用synchronized修饰的同步方法，因为该类的默认实例（this）就是同步监视器，所以可以在同步方法中直接调用这三个方法；

二、对于使用synchronized修饰的同步代码块，不同监视器是synchronized后括号里的对象，所以必须使用该对象调用这三个方法。

三个方法的解释如下：

wait（）：导致当前线程等待，直到其他线程调用该同步监视器的notify（）或notifyAll（）方法来唤醒该线程。无参数的wait（），一直等待直到其他线程通知；带时间参数的wait（）等待指定时间后自动苏醒。调用wait（）方法的当前线程会释放对该同步监视器的锁定。

notify（）：唤醒在此同步监视器上等待的单个线程。

notifyAll（）：唤醒在此同步监视器上等待的全部线程。

线程池

系统启动一个线程成本较高，可以用线程池来解决。程序将一个Runnable对象传 给线程池，线程池会启动一条线程来执行该对象的Run方法，结束后该线程不会死亡，而是返回线程池称为空闲状态。

创建线程池：

newcachedThreadPool（）、newFixedThreadPool（）、newSingleThreadExecutor（）都返回一个ExecutorService对象，该对象代表一个线程池，它可以执行runnable对象或Callable对象（Java借鉴C#语言的线程）所代表的线程。

提供的方法：submit（）将Runnable对象提交给线程池；shutdown（）关闭线程池。

newCachedThreadPool()线程池提供的线程默认都是守护线程，若不想使用守护线程，可使用如下方法：

ExecutorService executor=Executors.newCachedThreadPool(new DeamonThreadFactory(false));//当然首先要定义DeamonThreadFactory类，来生产非守护线程.

注：守护线程必须依赖于前台线程存在