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

posted @ 2015-04-01 17:48  xingoo  阅读(...)  评论(... 编辑 收藏