Java多线程是Java开发中的基础内容,但是涉及到高并发就有很深的研究可做了。 最近看了下《Java并发实战》,发先有些地方,虽然可以理解,但是自己在应用中很难下手。
所以还是先回顾一下基础知识:
线程的相关知识,了解操作系统的基本都能有所了解。
线程有5中状态,基本变化如图所示:
众所周知,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