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();
    }
}

     

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

（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，反之！