自学多线程-2

线程的状态转换如下所示：

分析可知，线程启动之后处于就绪状态，要等待CPU进行调度，并不是立刻启动的。

线程的常用方法：

方法	功能
currentThread()	获得当前运行的线程
getName()	获得当前线程的名称
setName()	设置线程的名称
isAlive()	判断线程是否还"活"着，即线程是否还未终止
sleep()	将当前线程睡眠指定的毫秒数
join()	调用A线程的该方法，将当前线程与A线程"合并"，即等待A线程结束，再回复当前线程的运行。

 setName():

线程的名字一般在启动线程前设置，但也允许为已经运行的线程设置名字。允许两个Thread对象有相同的名字，但为了理解方便，应该尽量避免这种情况。

代码示例：

class Kirl implements Runnable
{
    public void printText()
    {
        for(int i = 0;i < 5;i++)
        {
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
    public void run()
    {
        printText();
    }
}
public class TestThread {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Kirl k1 = new Kirl();
        Thread t1 = new Thread(k1,"Thread1");
        t1.start();
        k1.printText();
    }
}

输出结果为：

main->0
Thread1->0
Thread1->1
Thread1->2
Thread1->3
Thread1->4
main->1
main->2
main->3
main->4

由以上程序分析可知，main方法也是一个线程，所以之前的所有程序都是基于多线程的运行机制，在main方法中通过对象.方法调用的一切代码都是主线程。

isAlive():

start()方法通知线程规划器这个新线程已准备就绪，而且应当在规划器的最早方便时间调用它的run()方法。那么isAlive()方法的作用就是用来测试线程是否已经启动而且仍然启动。

示例代码如下：

class Kirl implements Runnable
{
    public void printText()
    {
        System.out.println(Thread.currentThread().getName());
    }
    public void run()
    {
        printText();
    }
}
public class TestThread {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Kirl k1 = new Kirl();
        Thread t1 = new Thread(k1,"Thread1");
        System.out.println("Before start thread:" + t1.isAlive());
        t1.start();
        System.out.println("After start thread:" + t1.isAlive());
        Thread.sleep(3000);
        System.out.println("After sleep thread:" + t1.isAlive());
    }
}

输出结果为：

Before start thread:false
After start thread:true
Thread1
After sleep thread:false

综上所述，isAlive方法在线程执行之后进行判断时，结果没有固定的内容，因为线程有可能优先执行完，也有可能在最后执行完。

join():

在线程中使用join()方法，用于强制某一线程运行。

代码示例如下：

class Kirl implements Runnable
{
    public void printText()
    {
        for(int i = 0;i < 10;i++)
        {
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
    public void run()
    {
        printText();
    }
}
public class TestThread {
    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Kirl k1 = new Kirl();
        Thread t1 = new Thread(k1,"Thread1");
        t1.start();
        for(int i = 0;i < 10;i++)
        {
            if(i == 5)
            {
                t1.join();
            }
            System.out.println(Thread.currentThread().getName() + "->" + i);
        }
    }
}

输出结果为：

main->0
main->1
main->2
main->3
main->4
Thread1->0
Thread1->1
Thread1->2
Thread1->3
Thread1->4
Thread1->5
Thread1->6
Thread1->7
Thread1->8
Thread1->9
main->5
main->6
main->7
main->8
main->9
由输出结果可得结论，当运行到i=5时，Thread1线程便开始一直执行，直到结束，main线程才可以执行。join()方法指一个线程必须运行完成之后其它的线程才可以继续运行，表示强制性运行。