Java入门教程十三(多线程)

线程的概念

单纯种以一个任务完成以后再进行下一个任务的模式进行，这样下一个任务的开始必须等待前一个任务的结束，只有一个任务完成后才能进行下一个任务。Java 语言提供了并发机制，允许开发人员在程序中执行多个线程，每个线程完成一个功能，并与其他线程并发执行。这种机制被称为多线程。操作系统以进程为单位，我们下Windows

系统可以分配给每个进程一段有限的执行 CPU 的时间（也称为 CPU 时间片），CPU 在这段时间中执行某个进程，然后下一个时间段又跳到另一个进程中去执行。由于 CPU 切换的速度非常快，给使用者的感受就是这些任务似乎在同时运行，所以使用多线程技术后，可以在同一时间内运行更多不同种类的任务。

单任务的特点就是排队执行，也就是同步，就像在 cmd 中输入一条命令后，必须等待这条命令执行完才可以执行下一条命令一样。

CPU 完全可以在任务 1 和任务 2 之间来回切换，使任务 2 不必等到 5 秒再运行，系统的运行效率大大得到提升。这就是要使用多线程技术，线程可以理解成是在进程中独立运行的子任务。

实现方式

实现多线程编程的方式主要有两种：一种是继承 Thread 类，另一种是实现 Runnable 接口

Thread类

public Thread(String threadName)
public Thread()

public class NewThread extends Thread{
	 @Override
    public void run(){
       //线程的执行代码
    }
}
//使用
new NewThread().start();

线程实现的业务代码需要放到 run() 方法中。当一个类继承 Thread 类后，就可以在该类中覆盖 run() 方法，将实现线程功能的代码写入 run() 方法中，然后同时调用 Thread 类的 start() 方法执行线程，也就是调用 run() 方法

Runnable接口

如果要创建的线程类已经有一个父类，这时就不能再继承 Thread 类，因为 Java 不支持多继承，所以需要实现 Runnable 接口来应对这样的情况

public Thread(Runnable r);
public Thread(Runnable r,String name);

public class MyRunnable implements Runnable{
    @Override 
    public void run(){ 
        //线程的执行代码
    }
}
//使用
Runnable runnable=new MyRunnable();
Thread thread=new Thread(runnable);
thread.start();

线程的生命周期

线程也具有生命周期，主要包括 7 种状态，分别是出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态

出生状态：用户在创建线程时所处的状态，在用户使用该线程实例调用 start() 方法之前，线程都处于出生状态。

就绪状态：也称可执行状态，当用户调用 start() 方法之后，线程处于就绪状态。

运行状态：当线程得到系统资源后进入运行状态。

等待状态：当处于运行状态下的线程调用 Thread 类的 wait() 方法时，该线程就会进入等待状态。进入等待状态的线程必

须调用 Thread 类的 notify() 方法才能被唤醒。notifyAll() 方法是将所有处于等待状态下的线程唤醒。

休眠状态：当线程调用 Thread 类中的 sleep() 方法时，则会进入休眠状态。

阻塞状态：如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时，线程进入就绪状态。对阻塞的线程来说，即使系统资源关闭，线程依然不能回到运行状态。

死亡状态：当线程的 run() 方法执行完毕，线程进入死亡状态。

同步机制 synchronized

为了处理这种共享资源竞争，可以使用同步机制。所谓同步机制，指的是两个线程同时作用在一个对象上，应该保持对象数据的统一性和整体性。Java 提供 synchronized 关键字，为防止资源冲突提供了内置支持。

同步方法

class className{
    public synchronized type methodName(){
        //代码
    }
}

同步块

synchronized(obj){
    //代码
}
public class test{
	Object obj=new Object();
	public void method(){
     	synchronized(obj){
        	//代码
    	}
	}
}

同步的多线程与单线程有本质的区别，当处理一段非常复杂的业务时，使用了多线程处理，只有被synchronized的代码块才会被进行顺序执行，其他的业务代码都是在不同的线程里各自执行。

curentThread()

返回代码段正在被哪个线程调用的线程相关信息

public static void main(String[] args)
{
   //调用currentThread()方法输出当前线程名称
   System.out.println(Thread.currentThread().getName());
}
public class MyThread extends Thread{
	@Override 
   public void run(){
   		System.out.println(Thread.currentThread().getName()); 
   }
}
MyThread myThread=new MyThread();
Thread t = new Thread(myThread);
t.setName("myThread");
t.start();//输出myThread;

isAlive()

isAlive() 方法的作用是判断当前的线程是否处于活动状态。什么是活动状态呢？活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态，就认为线程是“存活”的

public class MyThread extends Thread
{
    @Override 
    public void run()
    { 
        System.out.println("run="+this.isAlive()); 
    }
}
public static void main(String[] args)
{
    MyThread mythread=new MyThread(); 
    System.out.println("begin="+mythread.isAlive());   //输出线程状态
    mythread.start();                                  //启动线程
    System.out.println("end="+mythread.isAlive());     //输出线程状态
}
//输出
begin==false
end==true或false//这里要注意，由于另启一个线程，去执行代码，end有可能在线程启动前执行(此情况end为false)，也有可能在线程启动后执行(此情况end为ture)
run=true

sleep()

sleep() 方法的作用是在指定的毫秒数内让当前“正在执行的线程”休眠（暂停执行）

public class MyThread extends Thread
{
    @Override 
    public void run()
    { 
        System.out.println("开始"); 
        Thread.sleep(2000);        //延时2秒
        System.out.println("结束"); 
    }
}

getId()

getId() 取得正在运行线程的唯一标识

Thread thread=Thread.currentThread();
System.out.println(thread.getId());

线程暂停

暂停线程意味着此线程还可以恢复运行。使用 suspend() 方法暂停线程，使用 resume() 方法恢复线程的执行

public class MyThread extends Thread
{
    private long i=0;
    public long getI()
    {
        return i;
    }
    public void setI(long i)
    {
        this.i=i;
    }
    @Override
    public void run()
    {
        while(true)
        {
            i++;
        }
    }
}
public static void main(String[] args){
     MyThread thread=new MyThread();
     thread.start();
     System.out.println("线程开始");
     System.out.println(System.currentTimeMillis()+" i= "+thread.getI());//输出i的值
     thread.suspend();//暂停
     System.out.println("线程暂停5秒");
     Thread.sleep(5000);
     thread.resume();//开始
     System.out.println(System.currentTimeMillis()+" i= "+thread.getI());//继续暂停后i的值
}       

注意：在使用 suspend() 方法与 resume() 方法时，如果使用不当极易造成公共的同步对象被独占，从而使得其他线程无法访问公共同步对象。使用时要格外注意。

线程停止

停止一个线程意味着在线程处理完任务之前停掉正在做的操作，也就是放弃当前的操作。有三种方法可以停止线程

使用退出标识，使线程正常退出，也就是当 run() 方法完成后线程终止。
使用 stop() 方法强行终止线程，但是不推荐使用这个方法，因为 stop() 和 suspend() 及 resume() 一样，都是作废过期的方法，使用它们可能产生不可预料的结果。
使用 interrupt() 方法中断线程。

interrupt()

interrupt() 方法的作用是用来停止线程，但 intermpt() 方法的使用效果并不像循环结构中 break 语句那样，可以马上停止循环。调用 intermpt() 方法仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程

public class MyThread extends Thread
{
    @Override 
    public void run()
    { 
        for (int i=0;i<10000;i++)
        { 
            System.out.println(i+1);
        } 
    } 
}

public static void main(String[] args){ 
	MyThread thread=new MyThread();      //创建MyThread13线程类实例
	thread.start();    //启动线程
	Thread.sleep(100);    //延时100毫秒
	thread.interrupt();    //停止线程
}

主线程的运行结果如下所示。从中可以看到，虽然在延时 100 毫秒后调用 intermpt() 方法停止了 thread 线程，但是该线程仍然执行完成输出 10000 行信息。

判断线程是不是停止状态

this.interrupted()：测试当前线程是否已经中断。
this.islnterrupted()：测试线程是否已经中断。

stop()

调用 stop() 方法可以在任意情况下强制停止一个线程

public class MyThread extends Thread{
   private int i=0;
   @Override 
   public void run(){ 
 			while (true){
                i++;
                System.out.println("i=" + i);
                Thread.sleep(1000);
       	}
    } 
}
MyThread thread=new MyThread();
thread.start();
Thread.sleep(8000);
thread.stop();

线程在启动后有一个 8000 毫秒的延时，在这段时间内会循环 9 次，之后 stop() 方法被执行从而线程停止。运行后输出1到9

调用 stop() 方法时会抛出 java.lang.ThreadDeath 异常，但在通常情况下，此异常不需要显式地捕捉。使用 stop() 释放锁将会给数据造成不一致性的结果。如果出现这样的情况，程序处理的数据就有可能遭到破坏，最终导致程序执行的流程错误，一定要特别注意。