java 线程的基础知识总结

一、线程如何定义

        1.继承Thread类创建线程类

        2.通过实现Runnable接口传入Thread类创建线程。

        3.通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

        第一种方式的实现代码：

package com.thread;

public class FirstThreadTest extends Thread{
	int i = 0;
	//重写run方法，run方法的方法体就是现场执行体
	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 FirstThreadTest().start();
				new FirstThreadTest().start();
			}
		}
	}

}

                第二种方式的实现代码：

package com.thread;

public class RunnableThreadTest implements Runnable
{

	private int i;
	public void run()
	{
		for(i = 0;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)
			{
				RunnableThreadTest rtt = new RunnableThreadTest();
				new Thread(rtt,"新线程1").start();
				new Thread(rtt,"新线程2").start();
			}
		}

	}

}

 第三种方式的实现代码：

package com.thread;  
  
import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.FutureTask;  
  
public class CallableThreadTest implements Callable<Integer>  
{  
  
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }  
  
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
  
}  

二、线程的属性

三、线程的状态及转换

其中wait（）、notify（）、notifyAll（）都是Object的方法。

yield（）、sleep（）是Thread类的方法。

从图中可以看到阻塞分为三种阻塞的情况：

1.由join、sleep造成的阻塞，待join进来的线程执行完毕，或者sleep的时间到了，就可以又回到就绪状态。PS：sleep期间不释放锁。

2.运行的线程在获取对象的同步锁时（如synchronized同步造成的阻塞），若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。带其他线程释放了同步锁之后，可以回到就绪状态。

3.运行的线程执行wait()方法，JVM会把该线程放入等待池中。notify（）、notifyAll（）执行后，进入锁池。

进入就绪状态（runnable状态）的几种情况

1.Running状态的线程调用yield放弃处理机

2.锁池里面的线程获得锁

3.因sleep而阻塞的进程sleep时间到

4.被其他线程join的线程，join进来的线程执行完

5.线程正常启动。

四、线程间的竞争——并发

这里重点说下synchronized和volatitle

synchronized

synchronized的同步监视器可以是this、class、obj，持有同一个同步监视器的线程竞争访问同步进程块。

他们的区别是;

synchronized（this）｛｝该同步块所在类的对象中所有的synchronized（this）｛｝同步块只能被该线程访问；

synchronized（Class）｛｝所有Class类的对象将竞争访问同步块儿中的内容；

synchronized（Obj）｛｝一般用在线程内部

synchronized还可以修饰方法，修饰静态方法时，同步监视器等同于Class，修饰非静态方法时，同步监视器等同于this。

volatile 

Java 语言提供了一种稍弱的同步机制,即 volatile 变量.用来确保将变量的更新操作通知到其他线程,保证了新值能立即同步到主内存,以及每次使用前立即从主内存刷新. 当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的.volatile 变量对所有线程是立即可见的,对 volatile 变量所有的写操作都能立即反应到其他线程之中,换句话说:volatile 变量在各个线程中是一致的.但是对volatile 变量的读操作并不是一个原子操作，如果两个线程同时读取到了volatile 变量的值，同时进行了自增操作，再写入主存，最后主存中的结果只是加一的操作。

既然volatile 存在这样的问题，为什么还要使用它呢？

使用 volatile 变量的主要原因是其简易性：在某些情形下，使用 volatile 变量要比使用相应的锁简单得多。使用 volatile 变量次要原因是其性能：某些情况下，volatile 变量同步机制的性能要优于锁。

只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

• 对变量的写操作不依赖于当前值。
• 变量不需要与其他状态变量共同参与不变约束.这句话比较抽象。
  举个例子来说明下，比如start和end变量都被声明为volatile, 并且start和end组成不变约束start<end, 这样的不变约束是存在并发问题的:
  某一时刻，线程A获取了start、end的值分别为5和9，他根据不变约束，将start修改为7.
  此时，线程B也获取了start、end的值分别为5和9，他根据不变约束，将end修改为6.
  这样就打破了不变约束。

关于在竞争和同步过程中产生的死锁的问题和死锁的预防，将在以后的文章中介绍。

五、线程间的协作——通讯

线程之间不只是相互之间竞争资源，也可以通过相互之间的通讯更好的协同服务。

1.传统的通讯方式wait（）、notify（）、notifyAll（）

  wait（）、notify（）、notifyAll（）三个方法，他们都是Object的方法，并不属于Thread类。但这三个方法必须由同步监视器对象来调用，这可分成一下两种情况。

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

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

关于这是哪个方法解释如下：

  wait（）：导致当前线程等待，直到其他线程调用同步监视器的notify（）或者nofityAll（）来唤醒该线程。wait也可以带参数，表示多长时间后自动唤醒。

  notify（）：唤醒在此同步监视器上等待的单个线程。（具体唤醒谁，由具体的JVM来定）

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

2.使用Conditon控制线程通讯。

如果程序不使用synchronized关键字来保证同步，而是直接使用Lock对象来保证同步，则系统中不存在隐式的同步监视器，也就不能使用wait（）、notify（）、notifyAll（）。当使用Lock对象保证同步是，java提供了一个Conditon类来保持协调。具体将在后边的文章中详述。

3.使用阻塞队列（BlockingQueue）控制线程通信

  java 5提供了一个BlockingQueue，虽然BlockingQueue是Queue的子接口，但它的主要用途不是作为容器，而是作为线程同步的工具，BlockingQueue具有一个特征：当生产者试图向BlockingQueue中放去元素时，如果该队列已满，则该线程被阻塞；当消费者试图从BlockingQueue中取出元素时，如果该队列已空，则该线程被阻塞。

六、对线程的管理

线程组

为了线程进行管理，可以将线程分组。如果不指定线程组，子线程默认和父线程在一个线程组里。

线程池

系统启动一个新线程的成本是比较高的，因为它涉及与操作系统交互。在这种情形下，使用线程池能很好的提高性能，尤其是当程序中需要创建大量生存周期很短的线程时，更硬挨考虑使用线程池。

除此之外，使用线程池可以有效的控制系统中并发线程的数量，当系统中包含大量并发线程时，会导致系统性能剧烈下降，导致JVM崩溃，而线程池的最大线程数参数可以控制系统中并发线程数不超过此数。

七、对线程的特殊应用——Timer和TimerTask的使用

java.util.Timer timer = new java.util.Timer(true);   
// true 说明这个timer以daemon方式运行（优先级低，   
// 程序结束timer也自动结束），注意，javax.swing   
// 包中也有一个Timer类，如果import中用到swing包，   
// 要注意名字的冲突。   
  
TimerTask task = new TimerTask() {   
public void run() {   
... //每次需要执行的代码放到这里面。   
}   
};   
  
//以下是几种调度task的方法：   
  
timer.schedule(task, time);   
// time为Date类型：在指定时间执行一次。   
  
timer.schedule(task, firstTime, period);   
// firstTime为Date类型,period为long   
// 从firstTime时刻开始，每隔period毫秒执行一次。   
  
timer.schedule(task, delay)   
// delay 为long类型：从现在起过delay毫秒执行一次   
  
timer.schedule(task, delay, period)   
// delay为long,period为long：从现在起过delay毫秒以后，每隔period   
// 毫秒执行一次。