细说多线程之Thread VS Runnable

1.继承Thread类

package com.yd.test.testthread;

public class MyThread extends Thread {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("nihao");
        super.run();
    }

    public static void main(String[] args) {

        MyThread mt = new MyThread();//创建线程
        mt.start();//启动线程,当线程启动的时候,这个时候线程进入到线程队列中,这个时候等待cpu的服务,一旦它获取了CPU的时间片,这个时候它就会转到run方法中去执行,当run()中的逻辑执行完以后,这个线程
        //也就消亡了.
    }

}

2.实现Runnable接口

package com.yd.test.testthread;

public class MyThread1 implements Runnable {

    public static void main(String[] args) {
        MyThread1 mt1 = new MyThread1();
        Thread td = new Thread(mt1);//创建线程,只不过 传入了一个线程类的对象
        td.start();//启动线程,当start()的时候,同样线程会加入到线程队列中,一旦获取CPU的时间片之后就会转到run()中执行,当run()中的逻辑执行完以后,线程也就消亡了
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("nihao1");
    }
    
    /**
     * 无论哪种方法都需要创建线程类的对象,启动线程都需要调用start();
     * Runabble方式可以避免extends Thread单继承带来的缺陷
     * Runbale的代码可以实现多个线程实例的共享,适合多个线程处理同一资源的情况.
     */

}

3.火车票卖票案例

3.1 Thread类方式

package com.yd.test.testthread.ticketsThread;

/**
 * 线程的生命周期:
 * 创建状态(new Thread时候),
 * 就绪状态(start被调用后,加入到线程队列),
 * 运行状态(获取CPU时间片的时候),
 * 阻塞状态(由于某种原因,让出的CPU资源,比如sleep时候),
 * 终止状态(run执行完毕,人为终止)
 * @author think
 *用户线程:运行在前台,执行具体的任务:程序的主线程,连接网络的子线程等都是用户线程.
 *守护线程:运行在后台,为其他前台线程提供服务.
 *特点:一旦所有用户线程都结束运行,守护线程会随jvm一起结束工作
 *应用:数据库连接池的监测线程,jvm启动后的监测线程
 *最常见的守护线程:垃圾回收线程
 *设置:Thread.setDaemon(true)来设置当前线程为守护线程,必须在start()方法之前调用,否则会抛出IllegalThreadStateException.
 *在守护线程中产生的新线程也是守护线程,并不是所有的任务都可以分配给守护线程来执行的,比如读写操作或者计算逻辑
 */
class MyThread extends Thread {
    private int ticketsCount = 5;// 一共有5张火车票
    private String name;// 窗口,就是线程的名字

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        while (ticketsCount > 0) {
            ticketsCount--;// 如果还有票就卖掉一张
            System.out.println(name + "窗口卖了1张票,剩余票数为:" + ticketsCount);

        }
    }
}

public class TicketsThread {
    public static void main(String[] args) {
        //new了三个独立的Thread对象,他们是独立的,不是共享的,所以是卖了15张票.
        // 创建3个线程,模拟三个窗口买票
        MyThread t1 = new MyThread("窗口1");
        MyThread t2 = new MyThread("窗口2");
        MyThread t3 = new MyThread("窗口3");

        // 启动这三个线程,也就是三个窗口
        t1.start();
        t2.start();
        t3.start();

    }
}

3.2 Runnable方式

package com.yd.test.testthread.ticketsRunnable;

class MyThread implements Runnable {

    private int ticketsCount = 5;// 一共有5张票

    @Override
    public void run() {
        while (ticketsCount > 0) {
            ticketsCount--;// 如果还有票就卖掉一张
            System.out.println(Thread.currentThread().getName() + "卖掉了1张票,还剩下" + ticketsCount);
        }
    }

}

public class TicketsRunnable {
    public static void main(String[] args) {
        MyThread mt = new MyThread();//三个线程传递的是同一个runnable对象,用的也是runnable对象的同一个代码,相应的对应的资源(ticketsCount=5)也是共享的
        Thread t1 = new Thread(mt, "窗口1");
        Thread t2 = new Thread(mt, "窗口2");
        Thread t3 = new Thread(mt, "窗口3");

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

/**
 *  窗口2卖掉了1张票,还剩下3
    窗口3卖掉了1张票,还剩下2
    窗口1卖掉了1张票,还剩下3
    窗口3卖掉了1张票,还剩下0
    窗口2卖掉了1张票,还剩下1
    */

4.守护线程案例

package com.yd.test.testthread.daemon;

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

/**
 * 场景:一个主线程,一个守护线程: 守护线程是在某一个时间内不停的向文件中写数据,
 * 主线程会阻塞等待来自键盘的输入,一旦主线程获取到用户的输入,这个时候主线程就会解除阻塞,主线程继续运行直到结束,一旦主线程执行结束,用户线程就没有了.
 * 这个时候即使守护线程没有写完,守护线程也会随虚拟机一起消亡
 *
 * @author think
 *
 */

class DaemonThread implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("进入守护线程" + Thread.currentThread().getName());
        try {
            writeToFile();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("退出守护线程" + Thread.currentThread().getName());
    }

    private void writeToFile() throws IOException, InterruptedException {
        // TODO Auto-generated method stub
        File fileName = new File("d:" + File.separator + "daemon.txt");
        OutputStream os = new FileOutputStream(fileName, true);// true,说明每次都是追加操作,而不是覆盖操作
        int count = 0;
        while (count < 999) {
            os.write(("\r\nword" + count).getBytes());
            System.out.println("守护线程" + Thread.currentThread().getName() + "向文件中写入了word" + count++);
            Thread.sleep(1000);
        }
    }

}

public class DaemonThreadDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("进入主线程" + Thread.currentThread().getName());
        DaemonThread damonThread = new DaemonThread();
        Thread t = new Thread(damonThread);
        t.setDaemon(true);
        t.start();
        Scanner sc = new Scanner(System.in);//参数是System.in表示从键盘接收输入
        sc.next();//这个时候主线程就阻塞住了,一旦执行了输入操作,这个时候,阻塞就会解除掉,主线程就会继续往下执行,从而打印"退出运行".
        //由于主线程是唯一的用户线程,一旦主线程退出运行,守护线程就会退出运行.就会导致守护线程输入数据的不完整性
        System.out.println("退出主线程" + Thread.currentThread().getName());
    }

    /**
     * C:\Program Files\Java\jdk1.7.0_07\bin
     * jmap.exe:用来生成堆快照的
     * jstat.exe:监测虚拟机的运行状态的,查看jvm中内存使用的情况,类加载的情况,或者是所持有的情况等等.(生成jvm当前时刻线程的快照<Threaddump>即当前线程中所有线程的信息;目的:帮助定位
     * 程序问题出现的原因,如长时间停顿,CPU占用率过高等)
     * C:\Users\think>jstack
Usage:
    jstack [-l] <pid>pid:进程的id,有了这个参数就会打印出当前进程中所有线程的信息
        (to connect to running process)
    jstack -F [-m] [-l] <pid>
        (to connect to a hung process)
    jstack [-m] [-l] <executable> <core>
        (to connect to a core file)
    jstack [-m] [-l] [server_id@]<remote server IP or hostname>
        (to connect to a remote debug server)

Options:
    -F  to force a thread dump. Use when jstack <pid> does not respond (process is hung)
    -m  to print both java and native frames (mixed mode)
    -l  long listing. Prints additional information about locks 打印关于锁的附加信息
    -h or -help to print this help message
     * jconsole.exe和jstat的功能一样,是界面化工具.
     *
     *
     *
     *
     * C:\Users\think>jstack -l 10060
2017-12-26 13:44:26 快照的生成时间
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.131-b11 mixed mode): 使用的jvm类型,服务器端版本
 
 以下是所有的线程信息的快照:每一部分都对应一个线程的信息
 proio:优先级 tid nid:16进制,通过top工具,定位CPU占有率
"Thread-0" #10 daemon prio=5 os_prio=0 tid=0x00000000189c7000 nid=0xca0 waiting on condition [0x00000000194ef000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at com.yd.test.testthread.daemon.DaemonThread.writeToFile(DaemonThreadDemo.java:41)
        at com.yd.test.testthread.daemon.DaemonThread.run(DaemonThreadDemo.java:26)
        at java.lang.Thread.run(Thread.java:748)

   Locked ownable synchronizers:当前线程是否处于同步块内
        - None:没有
以下:是jvm启动的时候,自己启动起来的,无论运行那个程序都会起来
"Service Thread" #9 daemon prio=9 os_prio=0 tid=0x0000000018987800 nid=0x2728 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

//用来调用jit编译器的
"C1 CompilerThread2" #8 daemon prio=9 os_prio=2 tid=0x0000000018902000 nid=0x3340 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"C2 CompilerThread1" #7 daemon prio=9 os_prio=2 tid=0x00000000188ff000 nid=0x3e98 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"C2 CompilerThread0" #6 daemon prio=9 os_prio=2 tid=0x00000000188f9800 nid=0x3c94 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"Attach Listener" #5 daemon prio=5 os_prio=2 tid=0x0000000017421000 nid=0x2624 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"Signal Dispatcher" #4 daemon prio=9 os_prio=2 tid=0x00000000188f8800 nid=0x2eb0 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

   Locked ownable synchronizers:
        - None

"Finalizer" #3 daemon prio=8 os_prio=1 tid=0x000000000290d800 nid=0x1a20 in Object.wait() [0x000000001877e000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x00000000d6188ec8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:143)
        - locked <0x00000000d6188ec8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:164)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209)

   Locked ownable synchronizers:
        - None

"Reference Handler" #2 daemon prio=10 os_prio=2 tid=0x0000000002902800 nid=0x3ce0 in Object.wait() [0x000000001867e000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x00000000d6186b68> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:502)
        at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
        - locked <0x00000000d6186b68> (a java.lang.ref.Reference$Lock)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

   Locked ownable synchronizers:
        - None

主线程,没有daemon标记,说明是用户线程
"main" #1 prio=5 os_prio=0 tid=0x0000000002813800 nid=0x1f38 runnable [0x00000000027ff000]
   java.lang.Thread.State: RUNNABLE
        at java.io.FileInputStream.readBytes(Native Method)
        at java.io.FileInputStream.read(FileInputStream.java:255)
        at java.io.BufferedInputStream.read1(BufferedInputStream.java:284)
        at java.io.BufferedInputStream.read(BufferedInputStream.java:345)
        - locked <0x00000000d61dde10> (a java.io.BufferedInputStream)
        at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
        at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
        at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
        - locked <0x00000000d6267d78> (a java.io.InputStreamReader)
        at java.io.InputStreamReader.read(InputStreamReader.java:184)
        at java.io.Reader.read(Reader.java:100)
        at java.util.Scanner.readInput(Scanner.java:804)
        at java.util.Scanner.next(Scanner.java:1369)
        at com.yd.test.testthread.daemon.DaemonThreadDemo.main(DaemonThreadDemo.java:57)

   Locked ownable synchronizers:
        - None

"VM Thread" os_prio=2 tid=0x00000000173d7800 nid=0x488 runnable

"GC task thread#0 (ParallelGC)" os_prio=0 tid=0x0000000002829800 nid=0xcc4 runnable

"GC task thread#1 (ParallelGC)" os_prio=0 tid=0x000000000282b000 nid=0x13ec runnable

"GC task thread#2 (ParallelGC)" os_prio=0 tid=0x000000000282d000 nid=0x4270 runnable

"GC task thread#3 (ParallelGC)" os_prio=0 tid=0x000000000282e800 nid=0x15d8 runnable

"VM Periodic Task Thread" os_prio=2 tid=0x00000000189b5000 nid=0x3f04 waiting on condition

JNI global references: 6
     *
     *
     *
     *
     *
     */
}