使用Java实现面向对象编程——第七章 多线程

线程：是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，

但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，

同一进程中的多个线程之间可以并发执行。

线程：

1、线程是轻量级的进程

2、线程没有独立的地址空间(内存空间)

3、线程是由进程创建的(寄生在进程)

4、一个进程可以拥有多个线程-->这就是我们常说的多线程编程

线程的几种状态：

  a、创建状态(new)

  b、就绪状态(Runnable)

  c、运行状态(Running)

  d、阻塞状态(Blocked)

  e、死亡状态(Dead)

构造方法

 说       明

Thread()

分配新的Thread()对象

Thread(Runnable target)

分配新的Thread()对象。tarage为run()方法被调用的对象；

Thread(Runnable target,String nasme)

分配新的Thread()对象。tarage为run()方法被调用的对象；name为新线程的名称

void run（）

执行任务操作的方法

void start()

使该线程开始执行，JAVA虚拟机调用线程的run（）方法

static void sleep(long millis)

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

String getName（）

返回线程的名字

Int getPriority（）

返回线程的优先级

void setPriority(int  newPriority)

更改线程的优先级

static Thread currentThread()

返回当前正在执行的线程对象的引用

void join()

等待该线程终止

static void yield()

暂停当前正在执行的线程对象，并执行其他线程

void interrupt()

中断线程

boolean isAlive()

测试线程是否处于活动状态

●步骤：

      ★定义MyThread类继承Thread类

　　★重写run()方法，编写线程执行体

　　★创建线程对象，调用start()方法启动线程

Eg：

public class MyThread extends Thread{    //继承Thread类

       //重写run()方法

      public void run(){         //run()方法中编写线程执行的代码

            for(int i=1;i<100;i++){                

   　　　 System.out.println(Thread.currentThread().getName()+":"+i);

　　　　}

　　}

}

public static void main(String[] args) {

            MyThread thread = new MyThread();

            thread.start(); //启动线程

}

多个线程交替执行，不是真正的“并行”

线程每次执行时长由分配的CPU时间片长度决定

　　Eg：MyThread t1 = new MyThread();

　　　　MyThread t2 = new MyThread();

　　　　t1.start();

            t2.start();

直接调用run()和start()区别：

　　　　　　start（）：启动线程；

　　　　　　run（）：调用实例方法；

●步骤：

      ★定义MyRunnable类实现Runnable接口，并实现Runnable接口的run（）方法在run（）方法中实现输出数据；

　　★创建MyRunnable类的对象myRunnable；

　　★创建一个Thread类的对象myThread，将myRunnable对象作为Thread类构造方法的参数传入；

　　★调用myThread对象的start()方法启动线程；

Eg：

public class MyRunnable implements Runnable{   //实现Runnable接口

      public void run(){

            for(int i=1;i<100;i++){           //   run()方法中编写线程执行的代码

　　　　System.out.println(Thread.currentThread().getName()+":"+i);

　　　　}

　　}

}

public static void main(String[] args) {

            MyRunnable myRunnable = new MyRunnable();  //创建线程对象

            Thread myThread = new Thread(myRunnable); 

            thread.start();   //启动线程

}

■用实现Runnable接口的特点：

　　1、用实现Runnable接口的方法创建对象可以避免java单继承机制带来的局限；

　　2、用实现Runnable接口的方法，可以实现多个线程共享同一段代码(数据)；因此建议大家如果你的程序有同步逻辑需求，则使用Runnable的方法来创建线程。

比较两种创建线程的方式：推荐使用实现Runnable接口方式创建线程

　　★继承Thread类：

　　　　编写简单，可直接操作线程

　　　　适用于单继承

　　★实现Runnable接口：

　　　　避免单继承局限性

　　　　便于共享资源

附加：从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，

　　★从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口，区别如下：

　　　　1、尽可能使用实现Runnable接口的方式来创建线程

　　　　2、在使用Thread的时候只需要new一个实例出来，调用start()方法即可以启动一个线程，

　　　　　　　　如：      Thread test=new Thread();

                              　　　　  test.start();

　　　　3、在使用Runnable的时候需要先new一个实现Runnable的实例，之后用Thread调用，如:

                              Test implements Runnable

                               Test t=new Test();

                               Thread test=new Thread(t);

                               tset.start();

注意：不管是通过继承Thread，还是通过实现Runnable接口创建线程，它们的一个对象只能启动(即：start())一次。否则就会有（IllegaiIThreadStateException）异常抛出。

方法

说       明

setPriority(int  newPriority)

更改线程的优先级

static void sleep(long millis)

在指定的毫秒数内让当前正在执行的线程休眠

void join()

等待该线程终止

static void yield()

暂停当前正在执行的线程对象，并行其他线程

void interrupt()

中断线程

boolean isAlive()

测试线程是否处于活动状态

public static void main(String[] args) {

          Thread temp = new Thread(new MyThread());

          temp.start();

          for(int i=0;i<20;i++){

            if(i==5){                     

                  try {

                      temp.join();   //阻塞主线程，子线程强制执行

                  } catch (InterruptedException e) {

                       e.printStackTrace();

                     }

              }               

System.out.println(Thread.currentThread().getName()+"运行："+i);

      }

       //省略代码……

}

结果：

◆使用synchronized修饰的方法控制对类成员变量的访问

　　　　语法：

◆synchronized（同步关键字）就是为当前的线程声明一个锁

◆ syncObject为需同步的对象，通常为this，效果与同步方法相同

◆多个并发线程访问同一资源的同步代码块时注意：

　　1、当多个并发线程访问同一个对象object的synchronized（this）同步代码块时，同一时刻只能有一个线程得到执行，其他线程必须等待当前线程执行完毕之后才能执行该代码块；

　　2、当一个线程访问一个object的synchronized（this）同步代码块时，其他线程对object中所有其他synchronized（this）同步代码块的访问被阻塞，即该线程获得这个object的对象锁，其他线程对该object对象所有同步代码部分的访问被暂时阻塞；

　　3、当一个线程访问一个object的synchronized（this）同步代码块时，其他线程可以访问该资源的非synchronized（this）同步代码；

　　　　 综上所述：synchronized就是为当前线程声明一个锁，获得这个锁的线程可以执行代码块里的指令，其他的线程只能等待解锁，然后才能执行相同的操作；

◆同步代码块的应用场景：假设某线程是非线程安全的，而且该类是第三方创建的或者是从内置库导入的，所以不能获取他的源代码，这样，无法在相关方法前面加synchronized修饰符；

     怎样使该类的一个对象同步化？

   　　　　解决方案：只需将对调用该方法的代码放入一个synchronized块内就可以了；

　　　◆关键代码：

    　　　　  synchronized（同步对象）{

   　　　　　　//调用第三方非同步方法的代码

　　　　　　}

查看ArrayList类的add()方法定义：

public boolean add(E e) {

       ensureCapacityInternal(size + 1);// 集合扩容，确保能新增数据

       elementData[size++] = e;   //在新增位置存放数据

        return true;

    }

ArrayList类的add()方法为非同步方法；

当多个线程向同一个ArrayList对象添加数据时，可能出现数据不一致问题

ArrayList为非线程安全的类型

* 死锁:两个线程都在等待对方先完成，造成程序的停滞；

   * 产生死锁的条件：

         * 两个或两个以上的线程在活动；

         * 某个线程拿到一个锁以后，还想拿第二个锁，造成锁的嵌套?

   *解决方法：

         * 当前线程先释放自己的锁?

         * 尽量减少同步方法或同步代码块的嵌套?

Eg：两个小孩互换玩具；

Eg：此示例不会产生死锁；

/**

 * 模拟死锁

*/

public class Test {

   public static void main(String[] args) {

     Thread tang=new Thread(new Tang());

     Thread dou=new Thread(new Dou());

     tang.start();

     dou.start();

   }

}

/**

 * 堂堂

*/

class Tang implements Runnable{

   Object bobby=new Object();//芭比娃娃

   Object duck=new Object();//玩具

   @Override 

   public void run() {

     synchronized (bobby) {

        try {

           Thread.sleep(500);

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

        synchronized (duck) {

        }

        System.out.println("堂堂把芭比娃娃给豆豆玩！");

     }

   }

}

/**

 * 豆豆

*/

class Dou implements Runnable{

   Object bobby=new Object();//芭比娃娃

   Object duck=new Object();//玩具

   @Override 

   public void run() {

     synchronized (duck) {

        try {

           Thread.sleep(500);

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

        synchronized (bobby) {

        }

        System.out.println("豆豆把玩具鸭给堂堂玩");

     }

   }

}

Eg：此示例产生了死锁

/**

 * 模拟死锁(产生了死锁)

*/

public class Test1 {

   public static void main(String[] args) {

      Object bobby=new Object();

     Object duck=new Object();

     Thread tang=new Thread(new Tangtang(bobby,duck));

     Thread dou=new Thread(new Doudou(bobby,duck));

     tang.start();

     dou.start();

   }

}

/**

 * 堂堂

*/

class Tangtang implements Runnable{

   Object bobby;//芭比娃娃

   Object duck;//玩具

   //构造函数

   public Tangtang(Object bobby,Object duck) {

     super();

     this.bobby=bobby;

     this.duck=duck;

   }

   @Override 

   public void run() {

     synchronized (bobby) {

        try {

           Thread.sleep(500);

        } catch (InterruptedException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

        }

        synchronized (duck) {

        }

        System.out.println("堂堂把芭比娃娃给豆豆玩！");

     }

   }

}

/**

 * 豆豆

 */

class Doudou implements Runnable{

   Object bobby;//芭比娃娃

   Object duck;//玩具

   //构造函数

   public Doudou(Object bobby,Object duck) {

     super();

     this.bobby=bobby;

     this.duck=duck;

   }

   @Override 

   public void run() {

     synchronized (duck) {

        try {

           Thread.sleep(500);

        } catch (InterruptedException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

        }

        synchronized (bobby) {

        }

        System.out.println("豆豆把玩具鸭给堂堂玩");

     }

   }

}

Eg：一个轮流录入电影和读取电影信息的程序

            变形金刚——一部科幻电影

            神偷奶爸——一部3D动画片

    　　 分析： 生产者：录入信息；

　　　　消费者：读取信息；

/**

 * 电影类

 */

public class Movie {

   private String name;//电影的名称

   private String info;//电影的描述

   public String getName() {

     return name;

   }

   public void setName(String name) {

     this.name = name;

   }

   public String getInfo() {

     return info;

   }

   public void setInfo(String info) {

     this.info = info;

   }

}

/**

 * 生产者

 */

public class Producer implements Runnable {

   private Movie movie=null;

   private boolean flag=false;

   //构造函数

   public Producer(Movie movie) {

     super();

     this.movie=movie;

   }

   @Override

   public void run() {

     //循环录入50遍电影数据，两部电影交替录入

     for (int i = 0; i < 50; i++) {

        if(flag) {

           this.movie.setName("变形金刚");

           try {

             Thread.sleep(1000);

           } catch (InterruptedException e) {

             e.printStackTrace();

           }

           this.movie.setInfo("一部科幻电影！");

           flag=false;

        }else {

           this.movie.setName("神偷奶爸");

           try {

             Thread.sleep(1000);

           } catch (InterruptedException e) {

             e.printStackTrace();

           }

           this.movie.setInfo("一部3D动画电影");

           flag=true;

        }

     }

   }

}

/**

 * 测试类

 */

public class Test {

   public static void main(String[] args) {

     Movie movie=new Movie();

//生产者线程对象

Thread producer=new Thread(new Producer(movie));

//消费者线程对象

    Thread consumer=new Thread(new Consumer(movie));    producer.start();

     consumer.start();

   }

}

/**

 * 消费者

*/

public class Consumer implements Runnable {

   private Movie movie=null;

   //构造函数

   public Consumer(Movie movie) {

     super();

     this.movie=movie;

   }

   @Override

   public void run() {

     //循环显示50次电影信息

     for (int i = 0; i <50; i++) {

        try {

           Thread.sleep(1000);

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

           System.out.println(this.movie.getName()+"—

"+this.movie.getInfo());

     }

   }

}

输出结果：（会出现电影名与类型匹配错误的情况（生产与消费不同步））

/**

 * 生产者

*/

public class Producer implements Runnable {

   private Movie movie=null;

   private boolean flag=false;

   //构造函数

   public Producer(Movie movie) {

     super();

     this.movie=movie;

   }

   @Override

   public void run() {

     //循环录入50遍电影数据，两部电影交替录入

     for (int i = 0; i < 50; i++) {

        if(flag) {

           this.movie.set("变形金刚", "一部科幻电影");

           flag=false;

        }else {

           this.movie.set("神偷奶爸", "一部3D动画电影");

           flag=true;

        }

     }

   }

}

/**

 * 消费者

*/

public class Consumer implements Runnable {

   private Movie movie=null;

   //构造函数

   public Consumer(Movie movie) {

     super();

     this.movie=movie;

   }

   @Override

   public void run() {

     //循环显示50次电影信息

     for (int i = 0; i <50; i++) {

        try {

           Thread.sleep(100);

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

        this.movie.get();

     }

   }

}

package lianxi0Producer;

/**

 * 电影类

*/

public class Movie {

   private String name;//电影的名称

   private String info;//电影的描述

   public String getName() {

     return name;

   }

   public String getInfo() {

     return info;

   }

   //同步写入

   public synchronized void set(String name,String info) {

     this.name=name;

     try {

        Thread.sleep(100);

     } catch (InterruptedException e) {

        e.printStackTrace();

     }

     this.info=info;

   }

   //同步获取

   public synchronized void get() {

      System.out.println(this.getName()+"--"+this.getInfo());

   }

}

/**

 * 测试类

 */

public class Test {

   public static void main(String[] args) {

     Movie movie=new Movie();

//生产者线程对象

   Thread producer=new Thread(new Producer(movie)); 

//消费者线程对象

   Thread consumer=new Thread(new Consumer(movie));     producer.start();

     consumer.start();

   }

}

输出结果：（没有实现交替输出（需要调用Object类的两个方法））

notify() 唤醒正在等待对象监视器的单个线程。

Wait():导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。

/**

 * 生产者

*/

public class Producer implements Runnable {

   private Movie movie=null;

   private boolean flag=false;

   //构造函数

   public Producer(Movie movie) {

     super();

     this.movie=movie;

   }

   @Override

   public void run() {

     //循环录入50遍电影数据，两部电影交替录入

     for (int i = 0; i < 50; i++) {

        if(flag) {

           this.movie.set("变形金刚", "一部科幻电影");

           flag=false;

        }else {

           this.movie.set("神偷奶爸", "一部3D动画电影");

           flag=true;

        }

     }

   }

}

/**

 * 消费者

*/

public class Consumer implements Runnable {

   private Movie movie=null;

   //构造函数

   public Consumer(Movie movie) {

     super();

     this.movie=movie;

   }

   @Override

   public void run() {

     //循环显示50次电影信息

     for (int i = 0; i <50; i++) {

        try {

           Thread.sleep(100);

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

        this.movie.get();

     }

   }

}

/**

 * 电影类

*/

public class Movie {

   private String name;//电影的名称

   private String info;//电影的描述

   private boolean flag=true;//设置标志位置，控制生产者生产，消费者消费

   public String getName() {

     return name;

   }

   public String getInfo() {

     return info;

   }

   //同步写入

   public synchronized void set(String name,String info) {

     if(!flag) {

        try {

           super.wait();

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

     }

     this.name=name;

     try {

        Thread.sleep(100);

     } catch (InterruptedException e) {

        e.printStackTrace();

     }

     this.info=info;

     flag=false;//重置标志位，让消费者消费

     super.notify();

   }

   //同步获取

   public synchronized void get() {

     if(flag) {

        try {

           super.wait();

        } catch (InterruptedException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

        }

     }

     System.out.println(this.getName()+"—

"+this.getInfo());

     flag=true;

     super.notify();

   } 

}

/**

 * 测试类

 */

public class Test {

   public static void main(String[] args) {

     Movie movie=new Movie();

//生产者线程对象

   Thread producer=new Thread(new Producer(movie)); 

//消费者线程对象

   Thread consumer=new Thread(new Consumer(movie));     producer.start();

     consumer.start();

   }

}

输出结果：

方法名

说明

newCachedThreadPool()

创建一个可缓存的线程池，有任务时才创建新任务；

newSingleThreadExecutor()

创建一个单线程池

newFixedThreadPool(int nThreads)

创建一个固定长度的线程池，空闲线程池会一直保留，参数nThreads设定线程池中线程的数目

newScheaduledThreadPool(int corePoolSize)

创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务；

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

 * 使用newCacherThreadPool()方法创建线程池

 * @author 逆風?飛翔

 *

 */

public class Test {

   public static void main(String[] args) {

//创建一个线程池

     ExecutorService cachedThreadPool= Executors.newCachedThreadPool();

     //在线程池中执行10个任务

     for (int i = 0; i < 10; i++) {

        cachedThreadPool.execute(new MyRunnable(i));

        try {

           Thread.sleep(1000); //每执行一次休眠一秒

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

     }

   }

}

class MyRunnable implements Runnable{

   int num;

   public MyRunnable(int num) {

     super();

     this.num=num;

   }

   @Override

   public void run() {

      System.out.println(Thread.currentThread().getName()+":"+num);

   }

}

输出结果：pool代表线程池

（10个任务被同一个线程执行）

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

 * 使用newCacherThreadPool()方法创建线程池

 * @author 逆風?飛翔

 *

 */

public class Test {

   public static void main(String[] args) {

//创建一个线程池

     ExecutorService cachedThreadPool= Executors.newCachedThreadPool();   //在线程池中执行10个任务

     for (int i = 0; i < 10; i++) {

        cachedThreadPool.execute(new MyRunnable(i));

//      try {

//         Thread.sleep(1000);

//      } catch (InterruptedException e) {

//         e.printStackTrace();

//      }

     }

   }

}

class MyRunnable implements Runnable{

   int num;

   public MyRunnable(int num) {

     super();

     this.num=num;

   }

   @Override

   public void run() {

      System.out.println(Thread.currentThread().getName()+":"+num);

   }

}

结果：（更多的线程参与执行，有些线程执行了两次，

eg：线程8执行完7后，又继续执行了9，

省去创建一个新的线程，当有一个线程闲置下来后不需要去销毁，又去执行了一个新的任务）

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

 * 使用newSingleThreadExecutor()方法创建单线程池

*/

public class Test1 {

   public static void main(String[] args) {

//创建一个单线程池

     ExecutorService singleThreadPool= Executors.newSingleThreadExecutor();

     //在线程池中执行10个任务

     for (int i = 0; i < 10; i++) {

        singleThreadPool.execute(new MyRunnable(i));

//      try {

//         Thread.sleep(1000);

//      } catch (InterruptedException e) {

//         e.printStackTrace();

//      }

     }

   }

}

class MyRunnable implements Runnable{

   int num;

   public MyRunnable(int num) {

     super();

     this.num=num;

   }

   @Override

   public void run() {

      System.out.println(Thread.currentThread().getName()+":"+num);

   }

}

输出结果：

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

 * 使用newFixedThreadExecutor()方法创建单线程池

*/

public class Test2 {

   public static void main(String[] args) {

//创建一个线程池

     ExecutorService fixedThreadPool= Executors.newFixedThreadPool(3);

     //在线程池中执行10个任务

     for (int i = 0; i < 10; i++) {

        fixedThreadPool.execute(new McRunnable(i));

        try {

           Thread.sleep(1000);

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

     }

   }

}

class McRunnable implements Runnable{

   int num;

   public McRunnable(int num) {

     super();

     this.num=num;

   }

   @Override

   public void run() {

      System.out.println(Thread.currentThread().getName()+":"+num);

   }

}

输出结果：（只有三个线程在执行）

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

/**

 * 使用newSchediledThreadPool()方法来创建线程池

*/

public class Test3 {

   public static void main(String[] args) {

     //创建三个线程

      ScheduledExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(3);

      System.out.println("*************开始执行*************");

      scheduledThreadPool.scheduleAtFixedRate(new MdRunnable(), 5, 2, TimeUnit.SECONDS);

   }

}

class MdRunnable implements Runnable{

   @Override

   public void run() {

      System.out.println(Thread.currentThread().getName()+"延时5s执行，每2s执行一次");

   } 

}

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

 * 创建自定义线程池

*/

public class Test4 {

   public static void main(String[] args) {

     //创建一个自定义线程池（核心线程数，最大线程数，超出的线程消亡的时间，指定毫秒数，阻塞队列）

     ThreadPoolExecutor executor=new ThreadPoolExecutor(5, 7, 3000,

           TimeUnit.MICROSECONDS, new ArrayBlockingQueue<Runnable>(4));

     //执行12个任务

     for (int i = 1; i <=12; i++) {

        //i为传入当前执行的数量

        executor.execute(new MmRunnable(i));

        System.out.println("线程池中的线程数："+executor.getPoolSize()+

                        ",队列中等待执行的任务:"+executor.getQueue().size()+

                        ",已执行完成的任务数:"+executor.getCompletedTaskCount());       

     }

     executor.shutdown();//关闭线程池

   }

}

class MmRunnable implements Runnable{

   int num;//第几个任务

   public MmRunnable(int num) {

     super();

     this.num=num;

   }

   @Override

   public void run() {

     System.out.println("正在执行任务"+num);

     try {

        Thread.sleep(1000);

     } catch (InterruptedException e) {

        // TODO Auto-generated catch block

        e.printStackTrace();

     }

     System.out.println("任务"+num+"执行完毕！");

   }

}

运行结果：

（会创建第12个线程所以会报错）

●进程和线程的基本概念和原理：

　　一个进程至少包含一个线程，即主线程。

　　多个线程的执行时间是由CPU的时间片决定的，时长是随机的。

　　在单CPU计算机中，一个进程的多个线程是交替执行的，在某一时刻，只能执行一个线程。

●线程是进程的一个执行路径，而不是一个程序，

　　线程是进程中执行运算的最小单位，

　　多线程用于实现并发，

　　单CPU的计算机中，CPU每个时刻只能执行一条指令，将CPU的执行时间分成多个时间片，分配给不同的线程。

●线程的创建和启动。当线程被创建后，执行start()方法后，线程处于可运行状态。

　　当线程执行完一个时间片后继续回到就绪状态，等待CPU再次分配时间片，而不存在一个队列。

　　线程休眠后，处于阻塞状态。

●线程的创建和启动，线程类的定义有继承Thead类和实现Runable接口两种方式，

　　通过实现run()方法编写线程体，

　　已启动的线程不能重复调用start()方法，否则会报IllegalThreadStateException异常。

●当线程对象调用start()方法后，进入就绪状态，

　　当CPU分配时间片后即可执行，可以实现多线程并发，

　　而直接调用run()方法和调用普通方法一样，只有主线程一条执行路径，不能实现并发执行。

●eg：

分析：

 本题考察线程的状态。创建一个线程对象后，线程对象处于新建状态，执行start()方法后，处于就绪状态。休眠时处于阻塞状态，休眠后处于就绪状态，执行输出语句时处于执行状态。

Eg：

分析：

 本题主要考查线程的强制执行。当主线程 main方法执行System.out.println(a);这条语句时，线程还没有真正开始运行，或许正在为它分配资源准备运行。因为为线程分配资源需要时间，而main方法执行完t.start()方法后继续往下执行System.out.println(a);,这个时候得到的结果是a还没有被改变的值0 。怎样才能让输出结果为5， join() 方法提供了这种功能。它能够使调用该方法的线程在此之前执行完毕。

●eg：

分析：本题考察线程的创建。在自定义线程中如果没有重写run()方法，则默认执行父类Thread中的run()方法，因此不会出现编译错误，也无任务输出结果，

●Eg：

分析：本题考察如何获取当前线程。线程对象mt直接调用了run()方法，没有使用start()方法启动线程。因此本题目中只启动了主线程和new Thread(mt,"线程")，主线程的线程名为main.

Eg：

分析：sleep()方法，它不能终止一个线程，它是将线程睡眠一段时间。当时间结束以后，线程就会再次启动。它是不会交出线程锁的

Eg：

分析：

因为currentThread()是静态方法，使用类名可直接调用。

Eg：

分析：

本题考察线程安全的类型。当多个线程共同操作Counter类的成员变量count时，会引出线程安全问题。解决问题的办法就是对addCount()方法加锁。如果将count变量定义在addCount()方法中，就不会存在多线程共同操作的数据，不会引发并发问题，本题答案为bc

Eg;

D：一个类中可以有多个同步方法或同步代码块;

●synchronized用来定义同步方法或同步代码块，解决多个线程共享资源时带来的问题，同步后，只允许一个线程进入同步方法或同步代码块。

  对于synchronized关键字最精准的描述：保证在某个时刻只有一个线程可以访问方法或对象；

●synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。