1.线程概述
程序员可以在程序中执行多个线程，每一个线程完成一个功能，并与其他线程并发执行，这种机制被称为多线程。
Windows操作系统是多任务操作系统，它以进程为单位。一 个进程是一个包含有自身地址的程序，每个独立执行的程序都称为进程，也就是正 在执行的程序。系统可以分配给每个进程一段有限的使用CPU的时间（也可以称为 CPU时间片），CPU在这段时间中执行某个进程，然后下一个时间片又跳至另一个进 程中去执行。由于CPU转换较快，所以使得每个进程好像是同时执行一样。
2.实现线程的两种方式
两种方式实现线程，分别为继承java.lang.Thread类与实现java.lang.Runnable接口
(1).继承Thread类
Thread类是java.lang包中的一个类，从这个类中实例化的对象代表线程，程序员启动一个新线程需要建立Thread实例.
常用的两种构造方法：
public Thread()：创建一个新的线程对象。
public Thread(String threadName)：创建一个名称为threadName的 线程对象
继承Thread类创建一个新的线程的语法
public class ThreadTest extends Thread{
}完成线程真正功能的代码放在类的run()方法中，当一个类继承Thread类后， 就可以在该类中覆盖run()方法，将实现该线程功能的代码写入run()方法中，然后同时调用Thread类中的start()方法执行线程，也就是调用run()方法。
run()方法必须使用以下语法格式
public void run(){
}注意如果start()方法调用一个已经启动的线程，系统将抛出IllegalThreadStateException异常。
Thread实例：
public class ThreadTest Extends Thread{//指定类继承Thread类
private int count=10;
public void run(){//重写run()方法
while(true){
System.out.println(count+" ");
if(--count==0){
return;
}
}
}
public static void main(String[] args){
new ThreadTest().start();
}
}继承了Thread类，然后在类中覆盖了run()方法。通常在run() 方法中使用无限循环的形式，使得线程一直运行下去，所以要指定一个跳出循环的条件.
在main方法中，使线程执行需要调用Thread类中的start()方法，start()方法调用被覆盖的run()方法，如果不调用start()方法，线程永远都不会启动，在主方法没有调用start()方法之前，Thread对象只是一个实例，而不是一个真正的线程。
(2).实现Runnable接口
实现Runnable接口的语法如下：
public class Thread extends Object implements Runnable
查询API从中可以发现，实质上Thread类实现了Runnable接口，其中的run()方法正是对Runnable接口中的run()方法的具体实现.
实现Runnable接口的程序会创建一个Thread对象，并将Runnable对象与 Thread对象相关联。Thread类中有以下两个构造方法：
public Thread(Runnable target)。
public Thread(Runnable target,String name)。
这两个构造方法的参数中都存在Runnable实例，使用以上构造方法就可以将Runnable实例与Thread实例相关联。
使用Runnable接口启动新的线程的步骤如下：
a.建立Runnable对象。
b.使用参数为Runnable对象的构造方法创建Thread实例。
c.调用start()方法启动线程
通过Runnable接口创建线程时程序员首先需要编写一个实现Runnable接口的类，然后实例化该类的对象，这样就建立了Runnable对象；接下来使用相应的构造 方法创建Thread实例；最后使用该实例调用Thread类中的start()方法启动线程。
3.线程的生命周期
线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。
出生状态就是线程被创建时处于的状态，在用户使用该线程实例调用start()方法之前线程都处于出生状态.
当用户调用start()方法后，线程处于就绪状态（又被称为可执行状态）.
当线程得到系统资源后就进入运行状态。一旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入 等待、休眠、阻塞或死亡状态。
当处于运行状态下的线程调用Thread类中的wait() 方法时，该线程便进入等待状态，进入等待状态的线程必须调用Thread类中的notify()方法才能被唤醒，而notifyAll()方法是将所有处于等待状态下的线程唤醒。
当线程调用Thread类中的sleep()方法时，则会进入休眠状态。
如果一个线程在运行状态下发出输入／输出请求，该线程将进入阻塞状态，在其等待输入／输出结束时线程进入就绪状态，对于阻塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态。
当线程的run()方法执行完毕时，线程进入死亡状态。
线程的各种状态
虽然多线程看起来像同时执行，但事实上在同一时间点上只有一个线程被执行，只是线程之间切换较快，所以才会使人产生线程是同时进行的假象。
使线程处于就绪状态有以下几种方法：
调用sleep()方法。
调用wait()方法。
等待输入／输出完成。
当线程处于就绪状态后，可以用以下几种方法使线程再次进入运行状态。
线程调用notify()方法。
线程调用notifyAll()方法。
线程调用interrupt()方法。
线程的休眠时间结束。
输入／输出结束。
4.操作线程的方法
(1).sleep()方法需要一个参数用 于指定该线程休眠的时间，该时间以毫秒为单位,通常在run（）方法内循环使用。
sleep()方法语法：
try{
Thread.sleep(2000);
}catch(InterruptedException e){
e.printStackTrace();
}由于sleep()方法的执行有可能抛出InterruptedException异常，所以将sleep()方法的调用放在try-catch块中。虽然使用了sleep()方法的线程在一段时间内会醒来，但是并不能保证它醒来后进入运行状态，只能保证它进入就绪状态。
(2).线程的加入
当某个线程使用join()方法加入到另外一个线程时，另一个线程会等待该线程执行完毕后再继续执行。
(3).线程的中断
在run()方 法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。
public class InterruptedTest implements Runnable{
private boolen isContinue=false;//设置一个标记变量，默认值为false
public void run(){//重写run（）方法
while(true){
//..
if(isContinue）//当isContinue变为true时，停止线程
break;
}
}
public void setContinue(){//定义设置isContinue变量为true的方法
this.isContinue=true;
}
}如果线程是因为使用了sleep()或wait()方法进入了就绪状态，可以使用 Thread类中interrupt()方法使线程离开run()方法，同时结束线程，但程序会抛出InterruptedException异常，用户可以在处理该异常时完成线程的中断业务处理，如终止while循环。
(4).线程的礼让
hread类中提供了一种礼让方法，使用yield()方法表示，它只是给当前正处于运行状态的线程一个提醒，告知它可以将资源礼让给其他线程，但这仅是一种暗示，没有任何一种机制保证当前线程会将资源礼让。
yield()方法使具有同样优先级的线程有进入可执行状态的机会，当当前线程 放弃执行权时会再度回到就绪状态。
5.线程的优先级
如果使用多线程程序，就会发生两个线程抢占资源的问题，Java提供了线程同步的机制来防止资源访问的冲突。
(1).线程安全
以火车站售票系统为例，在代码中判断当前票数是否大于0，如果大于0则执行将该票出售给乘客的功能，但当两个线程同时访问这段代码时（假如这时只剩下一张票），第一个线程将票售出，与此同时第二 个线程也已经执行完成判断是否有票的操作，并得出票数大于0的结论，于是它也执行售出操作，这样就会产生负数.所以在编写多线程程序时，应该考虑到线程安全问题。
public class ThreadSafeTest implements Runnable{
int num=10;//当前总票数
public void run(){
while(true){
if(num>0){
try{
Thread.sleep(100);
}catch(Exception e){
e.printStackTrace();
}
System.out.println("tickets"+num--);
}
}
}
public static void main(String[] args){
ThreadSafeTest t=new ThreadSafeTest();
Thread tA=new Thread(t);
Thread tB=new Thread(t);
Thread tC=new Thread(t);
Thread tD=new Thread(t);
tA.start();
tB.start();
tC.start();
tD.start();
}
}输出结果
tickets8
tickets7
tickets10
tickets9
tickets6
tickets5
tickets4
tickets3
tickets2
tickets1
tickets0
tickets-1
tickets-2实质上线程安全问题来源于两个线程同时存取单一对象的数据。
可以看出，最后打印售剩下的票为负值，这样就出现了问题。这是由于同时创建了4个线程，这4个线程执行run()方法，在num变量为1时，线程1、线 程2、线程3、线程4都对num变量有存储功能，当线程1执行run()方法时，还没有来得及做递减操作，就指定它调用sleep()方法进入就绪状态，这时线程2、线程3和 线程4都进入了run()方法，发现num变量依然大于0，但此时线程1休眠时间已到， 将num变量值递减，同时线程2、线程3、线程4也都对num变量进行递减操作，从而产生了负值。
(2). 线程同步机制
基本上所有解决多线程资源冲突问题的方法都是采用给定时间只允许一个线程访问共享资源，这时就需要给共享资源上一道锁。这就好比一个人上洗手间时，他进入洗手间后会将门锁上，出来时再将锁打开，然后其他人才可以进入。
a.同步块
在Java中提供了同步机制，可以有效地防止资源冲突。同步机制使用 synchronized关键字。
public class ThreadSafeTest implements Runnable{
int num=10;//当前总票数
public void run(){
while(true){
synchronized(" "){
if(num>0) {
try {
Thread.sleep (100);
} catch (Exception e) {
e.printStackTrace ();
}
System.out.println ("tickets" + --num);
}
}
}
}
public static void main(String[] args){
ThreadSafeTest t=new ThreadSafeTest();
Thread tA=new Thread(t);
Thread tB=new Thread(t);
Thread tC=new Thread(t);
Thread tD=new Thread(t);
tA.start();
tB.start();
tC.start();
tD.start();
}
}输出结果
tickets10
tickets9
tickets8
tickets7
tickets6
tickets5
tickets4
tickets3
tickets2
tickets1
tickets0同步块也被称为临界区，它使用synchronized关键字建立，其语法如下：
synchronized(Object){
}通常将共享资源的操作放置在synchronized定义的区域内，这样当其他线程也获取到这个锁时，必须等待锁被释放时才能进入该区域。Object为任意一个对象， 每个对象都存在一个标志位，并具有两个值，分别为0和1。一个线程运行到同步块时首先检查该对象的标志位*，如果为0状态，表明此同步块中存在其他线程在运行*。 这时该线程处于就绪状态，直到处于同步块中的线程执行完同步块中的代码为止。 这时该对象的标志位被设置为1，该线程才能执行同步块中的代码，并将Object对 象的标志位设置为0，防止其他线程执行同步块中的代码。
b. 同步方法
同步方法就是在方法前面修饰synchronized关键字的方法
其语法如下： synchronized void f(){ }
当某个对象调用了同步方法时，该对象上的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个能访问共享资源的方法修饰为synchronized， 否则就会出错。
定义同步方法实例
public synchornized void doit(){
if(nun>0){
try{
Thread.sleep(10);
}catch(Exception e){
e.printlnStackTrace();
}
System.out.println("tickets"+--num);
}
}
public void run(){
while(true){
doit();
}
}将共享资源的操作放置在同步方法中，运行结果与使用同步块的结果一致。
