Java多线程之Runable与Thread

Java多线程是Java开发中的基础内容，但是涉及到高并发就有很深的研究可做了。

最近看了下《Java并发实战》，发先有些地方，虽然可以理解，但是自己在应用中很难下手。

　　所以还是先回顾一下基础知识：

Java中的线程

　　线程的相关知识，了解操作系统的基本都能有所了解。

　　线程有5中状态，基本变化如图所示：

如何在Java代码中创建线程

　　众所周知，Java创建线程有两种方式：

　　1 实现Runable接口

　　2 继承Thread类

　　那么这两种方式有什么区别呢？

　　1 Runable属于接口，所以可以有多个实现；Thread只有一个。

　　2 实现Runable的线程类，可以被多个线程实例共享数据。

　　举个简单的例子，火车站售票处一共有3个售票口，但是只剩下5张票：

　　如果单纯使用Thread实现3个售票口的售票过程：

package com.imooc.test;
class MyThread extends Thread{
    
    private int ticketsCount = 5;
    private String name;
    
    public MyThread(String name){
        this.name = name;
    }
    
    @Override
    public void run() {
        while(ticketsCount > 0){
            ticketsCount--;
            System.out.println(name+" 卖了一张票，还剩下："+ticketsCount);
        }
    }
}
public class TicketsTestThread {
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("窗口1");
        MyThread mt2 = new MyThread("窗口2");
        MyThread mt3 = new MyThread("窗口3");
        
        mt1.start();
        mt2.start();
        mt3.start();
    }
}

　　执行结果如下：

窗口1 卖了一张票，还剩下：4
窗口2 卖了一张票，还剩下：4
窗口1 卖了一张票，还剩下：3
窗口1 卖了一张票，还剩下：2
窗口1 卖了一张票，还剩下：1
窗口1 卖了一张票，还剩下：0
窗口2 卖了一张票，还剩下：3
窗口2 卖了一张票，还剩下：2
窗口2 卖了一张票，还剩下：1
窗口2 卖了一张票，还剩下：0
窗口3 卖了一张票，还剩下：4
窗口3 卖了一张票，还剩下：3
窗口3 卖了一张票，还剩下：2
窗口3 卖了一张票，还剩下：1
窗口3 卖了一张票，还剩下：0

　　可以看到每个线程拥有自己的5张票，其实是重复了！

　　那么如果使用Runnable，则不会出现这种情况：

package com.imooc.test;
class MyRunnable implements Runnable{
    
    private int ticketsCount = 5;
    
    @Override
    public void run() {
        while(ticketsCount > 0){
            ticketsCount--;
            System.out.println(Thread.currentThread().getName()+" 卖了一张票，还剩下："+ticketsCount);
        }
    }
}
public class TicketsTestRunnable {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread th1 = new Thread(mr,"窗口1");
        Thread th2 = new Thread(mr,"窗口2");
        Thread th3 = new Thread(mr,"窗口3");
        
        th1.start();
        th2.start();
        th3.start();
    }
}

　　执行结果：

窗口1 卖了一张票，还剩下：4
窗口3 卖了一张票，还剩下：2
窗口3 卖了一张票，还剩下：1
窗口3 卖了一张票，还剩下：0
窗口2 卖了一张票，还剩下：3

　　这是因为创建Thread实例时，使用的是同一个MyRunnable类对象，所以会共享其中的数据。

用户线程与守护线程

　　在Java线程中，共有两类线程：

　　1 用户线程：用户代码生成

　　2 守护线程：用于特定的功能，当用户线程都结束时，守护线程会随着JVM的停止而停止，因此守护线程不能用于IO操作。

　　那么下面一个简单的守护线程的例子：

　　创建一个守护线程，持续不断的向文件中写入数据。主线程中启动该线程，然后主线程在一定时间后，退出。

　　观察守护线程的状态！

　　代码如下：

package com.imooc.test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.Scanner;

class DaemonThread implements Runnable{
    public void run() {
        System.out.println("进入守护线程:"+Thread.currentThread().getName());
        try {
            Write2File();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("退出守护线程:"+Thread.currentThread().getName());
    }
    public void Write2File() throws Exception{
        File filename = new File("d:"+File.separator+"daemon.txt");
        OutputStream os = new FileOutputStream(filename,true);
        int count = 0;
        while(count < 999){
            os.write(("\r\nword "+count).getBytes());
            System.out.println("守护线程"+Thread.currentThread().getName()+
                    "写入了 "+count);
            count++;
            Thread.sleep(1000);
        }
    }
}
public class DaemonTest {
    public static void main(String[] args) {
        System.out.println("进入主线程"+Thread.currentThread().getName());
        DaemonThread dt = new DaemonThread();
        Thread th = new Thread(dt);
        th.setDaemon(true);
        th.start();
        
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } 
        
        System.out.println("退出主线程"+Thread.currentThread().getName());
    }
}

　　当主线程睡眠了5秒后，便结束。此时JVM中没有其他的用户线程，于是守护线程也直接退出。

　　执行结果如下：

进入主线程main
进入守护线程:Thread-0
守护线程Thread-0写入了 0
守护线程Thread-0写入了 1
守护线程Thread-0写入了 2
守护线程Thread-0写入了 3
守护线程Thread-0写入了 4
退出主线程main

　　可以看到守护线程直接就中断退出了！

　　鉴于守护线程的这种特性，常用于实时监控系统状态。比如数据库，JVM等等。

查看线程快照

　　通过使用Jstack.exe程序，可以帮助用户查看线程状态。

　　使用方法：

　　1 查询线程PID

　　2 在cmd中输入jstack -l pid

C:\Users\Administrator>jstack -l 5028
2015-04-01 17:43:30
Full thread dump Java HotSpot(TM) Client VM (24.60-b09 mixed mode, sharing):

"Thread-0" daemon prio=6 tid=0x00928800 nid=0x2798 waiting on condition [0x03d4f
000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at com.imooc.test.DaemonThread.Write2File(DaemonTest.java:27)
        at com.imooc.test.DaemonThread.run(DaemonTest.java:12)
        at java.lang.Thread.run(Unknown Source)

   Locked ownable synchronizers:
        - None

"Service Thread" daemon prio=6 tid=0x008de000 nid=0xd64 runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"C1 CompilerThread0" daemon prio=10 tid=0x008dc400 nid=0x2158 waiting on conditi
on [0x00000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"Attach Listener" daemon prio=10 tid=0x008f4800 nid=0x13e0 waiting on condition
[0x00000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"Signal Dispatcher" daemon prio=10 tid=0x00905800 nid=0x1c7c runnable [0x0000000
0]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"Finalizer" daemon prio=8 tid=0x00875800 nid=0x2460 in Object.wait() [0x03e0f000
]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x23800fc8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(Unknown Source)
        - locked <0x23800fc8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(Unknown Source)
        at java.lang.ref.Finalizer$FinalizerThread.run(Unknown Source)

   Locked ownable synchronizers:
        - None

"Reference Handler" daemon prio=10 tid=0x00870800 nid=0x21c8 in Object.wait() [0
x03b6f000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x23800db0> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:503)
        at java.lang.ref.Reference$ReferenceHandler.run(Unknown Source)
        - locked <0x23800db0> (a java.lang.ref.Reference$Lock)

   Locked ownable synchronizers:
        - None

"main" prio=6 tid=0x0099c000 nid=0x14b8 waiting on condition [0x0052f000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at com.imooc.test.DaemonTest.main(DaemonTest.java:40)

   Locked ownable synchronizers:
        - None

"VM Thread" prio=10 tid=0x0086f000 nid=0x22dc runnable

"VM Periodic Task Thread" prio=10 tid=0x00927000 nid=0x131c waiting on condition


JNI global references: 111


C:\Users\Administrator>

　　其中详细的描述了线程的名字，是否为守护线程，以及状态等等。

参考

　　【1】慕课网Thread VS Runnable:http://www.imooc.com/learn/312