java线程详解（一）

1，相关概念简介

（1）进程：是一个正在执行的程序。每一个进程执行都有一个执行的顺序，该顺序就是一个执行路径，或者叫一个控制单元。用于分配空间。

（2）线程：就是进程中一个独立的控制单元，线程在控制着进程的执行，一个进程中至少有一个线程。

java虚拟机启动的时候会有一个进程java.exe，该进程中至少有一个线程在负责java程序的执行，这个线程运行的代码在main方法中，因此main方法是主线程。在更细节一点，java虚拟机不止一个线程，在启动main方法这个主线程时还有垃圾回收机制，其实这也是多线程。因此java虚拟机也是多线程。

2，线程的创建和启动

（1）继承Thread类创建线程

步骤：

（a）定义Thread类的子类。

（b）重写该Thread 类的run()方法。

（c) 创建一个线程对象。

（d）调用对象的start()方法启动进程，调用run()方法。

class Demo extends Thread   //（a）定义Thread类的子类。
{
    public void run(){   //（b）重写该Thread 类的run()方法。
        for(int i = 0; i < 100; i++){
            System.out.println(i + " demo run!");
        }

    }
    public static void main(String[] args)
    {
        Demo d = new Demo();  //（c) 创建一个线程对象。
        d.start();   //（d）调用对象的start()方法启动进程。
        //一下代码进行测试
        for(int i = 0; i < 100; i++){
            System.out.println(i + " main run!");
        }
    }
}

测试结果：

可以看出主线程和我们自定义的线程交替执行。

注意：

（a）创建的线程对象不能调用run()方法。如果调用run（）方法就和平常的函数调用一样，达不到多线程执行的效果。调用start()方法，不仅开启线程，而且还调用了run()方法。

（b） 该程序多次运行的结果每次都不同，这是因为多个线程都在争夺cpu的执行权，每一个时刻只有一个线程在运行，cpu在做着快速切换，以达到看上去是同时运行的结果。这就是多线程的一个特点：随机性。谁抢到谁执行，执行多长时间是有cpu决定的。

（c）为什么要覆盖run()方法？Thead类用于描述线程，该类中的run方法只是存放要运行的代码的位置。

（d）其实Thread d = new Thread()可以创建一个线程的实例，但是d.start()却是开启Thread类的run()方法，该方法没有做任何定义。

（2）实现Runnable接口创建线程类

先看一个问题

//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket extends Thread
{
    private int tick = 16;//票的张数---16
    public void run(){
        while(true){
            if(tick>0){
                //此处打印看是哪个窗口卖出的哪张票，这里简单的让票号从1  ---  16
                 System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);
            }
        }

    }
    public static void main(String[] args)
    {
        Ticket t1 = new Ticket();
        Ticket t2 = new Ticket();
        Ticket t3 = new Ticket();
        Ticket t4 = new Ticket();

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

    

结果我们可以看出不止卖了16张，其实每个窗口或者说线程都卖出16张票，这是不能忍受的。

有个方法：private int tick = 16；这句变为：private static int tick = 16。但一般不定义静态，因为它的生命周期太长。

正式进入第二种创建线程的方法：

//火车站有16张票，需要从四个窗口卖出，如果按照上面的多线程实现，程序如下
class Ticket implements Runnable
{
    private int tick = 16;//票的张数---16
    public void run(){
        while(true){
            if(tick>0){
                //此处打印看是哪个窗口卖出的哪张票，这里简单的让票号从1  ---  16
                 System.out.println(Thread.currentThread().getName() + "...sale:" + tick--);
            }
        }

    }
    public static void main(String[] args)
    {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

aaarticlea/png;base64,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" alt="" />

从这个结果我们可以看出达到了我们的目标。总结步骤：

（a）定义Runnable接口的实现类，并且重写该接口的run()方法。

（b）创建Runnable实现类的实例对象，并以此对象来作为Thread类的Target来创建Thread类对象。

Ticket t = new Ticket(); 该对象t并非是线程对象

Thread t1 = new Thread(t); 以对象t作为参数而创建的t1才是真正的线程对象

（c）调用该线程对象t1的方法start()来启动多线程。

可以在创建Thread对象时为该对象指定一个名字。

（3）常用方法

（a）返回对当前正在执行的线程对象的引用。

         public static Thread currentThread() 

（b）返回该线程对象的的名称。

public final String getName()

（4）注意事项

（a）继承Thread类的对象可以使用currentThread()方法，也可以使用this关键字。但是实现Runnable的实现类只能通过currentThread()方法获得当前对象。

（b）Runnable接口方式创建的多个线程可以共享线程类的实例的属性。所以非常适合多个相同的线程来处理同一份资源。（也就是为什么引出这种线程方式的卖票的那个例子）

（c）Runnable接口实现的方式下，还可继承其他的类。

3，线程的生命周期

新建：当程序使用new关键字创建一个线程对象时，该线程就处于新建状态，此时这个对象和其他java对象一样，仅仅有虚拟机为其分配内存，并初始化其初始值，此时的对象没有表现出线程的特征。

就绪：当新建的线程对象调用start()方法时（图中的1），该线程就处于就绪状态，虚拟机会为其创建方法调用栈和程序计数器，处于这个状态中的线程没有开始执行，只是表示可以执行了，至于什么时候执行，关键看虚拟机里面的调度器的调度。

运行：当就绪状态的现场获取了cpu的执行权（图中的2）开始执行run方法，则表示该线程处于运行状态。

阻塞：当线程开始运行时不可能一直处于运行状态，除非他的运行时间非常短，cpu还没有切换就已经运行结束，但这样的情况并不是大多数。一般情况下，cpu所分的时间片很多线程在这个时间内是完成不了的，此时线程运行就要中断，让其他线程获取执行机会。因此当一个运行中的线程发生如下情况时会进入阻塞状态。其实阻塞状态是一种运行中的线程的一种中断状态，此时不能运行，但是线程不能运行还有其他状态，比如说又恢复到就绪状态，下面就来说明。

（a）运行中的线程进入阻塞状态

（1）线程调用sleep()方法主动放弃所占用的处理器资源。

（2）线程调用了一个阻塞式的IO方法，在方法在返回前线程被阻塞。

（3）线程在等待某个通知。

（4）线程试图获得一个同步监视器，但是该同步监视器被别的线程所持有。

（5）程序调用了线程的suspend方法将该线程挂起。这个方法容易导致死锁，已过时。

（b）运行中的线程进入就绪状态

（1）并非通过sleep()方法使得线程失去资源

（2）调用yield()方法就可以使得运行中的程序进入就绪状态。

（c）阻塞状态的线程进入就绪状态

（1）阻塞状态的线程只能进入就绪状态，不能直接进入运行状态

（2）调用sleep()方法经过了指定的时间

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

（4）线程成功的获得了某个等待的同步监视器

（5）线程在等待某个通知，而其他线程发出了一个通知

（6）处于被挂起的线程被调用了resume()方法。这个方法容易导致死锁，已过时。

死亡：线程结束就是死亡状态。

（1）正常结束线程

（2）线程抛出一个未捕获到的Exception或Error。

（3）使用该线程的stop()方法来终止线程。容易死锁，已过时。

注意：

（a）当新建一个线程对象时，线程处于新建状态，此时如果要是调用了该对象的run()方法，说明此时线程对象已经不是新建状态了，不能再来调用start()方法，只能对处于新建状态的线程对象调用start()方法。但是也不能对新建的线程对象调用两次start()方法。

（b）不要对一个已经死亡的线程调用start()方法。

（c）有一个方法可以检测该线程对象是否已经死亡。-----isAlive()方法，当线程处于新建和死亡状态，该方法返回false，反之！