java多线程Runnable传参 java多线程api

Thread类相关状态和方法示意图：

线程状态和方法示意图

一. Thread类核心API使用

1. 进程是一次程序的执行，可以理解成Windows任务管理器的一个exe程序；线程是进程中独立运行的子任务。

2. 实现多线程编程有两种方式：

2.1 继承Thread类，覆盖run()。(Thread类也实现了Runnaable接口)

优点：如需访问当前线程，无需使用Thread.currentThread()方法。

缺点：已继承Thread类，不能再继承其他父类。

2.2 实现Runnable接口来创建(必须封装到Thread类)。

优点：还可以继承其他父类，适合多个相同线程来处理同一份资源。

缺点：如需访问当前线程，必须使用Thread.currentThread()方法。

使用多线程时，代码的运行结果与代码执行顺序或调用顺序无关。

3.currentThread()方法

Thread.currentThread().getName():返回代码段正在被哪个线程调用的信息。

4.isAlive():判断线程是否处于活动状态。package pgsthread;

public class TestAlive extends Thread{
public TestAlive(){
System.out.println("---TestAlive begins---");
System.out.println("Thread.currentThread().getName()="+Thread.currentThread().getName());
System.out.println("Thread.currentThread().isAlive()="+Thread.currentThread().isAlive());
System.out.println("this.getName()="+this.getName());
System.out.println("this.isAlive()="+this.isAlive());
System.out.println("---TestAlive ends---");
}
@Override
public void run(){
System.out.println("---run begins---");
System.out.println("Thread.currentThread().getName()="+Thread.currentThread().getName());
System.out.println("Thread.currentThread().isAlive()="+Thread.currentThread().isAlive());
System.out.println("this.getName()="+this.getName());
System.out.println("this.isAlive()="+this.isAlive());
System.out.println("---run ends---");
}
}package pgsthread;
public class Run {
public static void main(String[] args) {
TestAlive t = new TestAlive();
Thread t1 = new Thread(t);
//Thread(Runnable target):可以传入一个Thread类的对象，将t的run()交给t1执行。
System.out.println("main begin t1 isAlive="+t1.isAlive());
t1.setName("A");
t1.start();
System.out.println("main end t1 isAlive="+t1.isAlive());
}
}

运行结果如下：

---TestAlive begins---
Thread.currentThread().getName()=main
Thread.currentThread().isAlive()=true
this.getName()=Thread-0
this.isAlive()=false
---TestAlive ends---
main begin t1 isAlive=false
main end t1 isAlive=true
---run begins---
Thread.currentThread().getName()=A
Thread.currentThread().isAlive()=true
this.getName()=Thread-0
this.isAlive()=false
---run ends---

此处的Thread.currentThread()指向t1，this指向t。

5.判读线程是否是停止状态？

import pgsthread.TestAlive;
public class TestInterrupt {
public static void main(String[] args) {
Thread.currentThread().interrupt();
System.out.println(Thread.interrupted()); //true
System.out.println(Thread.interrupted()); //false
TestAlive t = new TestAlive();
t.start();
t.interrupt();
System.out.println(t.isInterrupted()); //true
System.out.println(t.isInterrupted()); //true
}
}

Thread.currentThread().interrupt();中断的是当前线程，即main。

this.interrupted():具有将状态位清楚为false的功能。

this.isInterrupted():不清除标志位。

6.主动行为——暂停线程使之阻塞

suspend():暂停线程；resume()：恢复线程的执行。

废弃上述两个方法的原因：

(1) 具有独占性，若在同步代码块中调用suspend()而一直未调用resume()，会锁死该同步代码块。

public void println(long x){
synchronized (this){
print(x);
newline();
}
}

如果在进入println(long x)内部是调用suspend()，将锁定该方法，同步锁将不释放。

(2) 不同步，导致线程不安全。

会导致同方法suspend()后的代码得不到执行。

7.线程优先级

setPriority():优先级分为1~10级，默认为5。

(1)线程的优先级具有继承性。

(2)优先级具有规则性：高优先级的线程总是大部分先执行完，但不代表高优先级的线程全部先执行完。

(3) 优先级具有随机性，并不一定优先级高的线程就一定先执行完。ps，线程优先级与代码中出现的先后顺序无关。

8.守护线程 Thread.setDaemon(true)

Java线程分为两种，一种是用户线程，另一种是守护(Daemon)线程。当进程中没有用户线程时，守护线程也将自动销毁。

二. 线程间通信

1.等待/通知(wait/notify)机制

(1) 不使用等待/通知机制

使用sleep()结合while(true)死循环轮询检测，会浪费CPU资源。即两个线程主动式的读取一个共享变量，在花费读取时间的基础上，读到的值不一定是想要的。

(2) 等待/通知机制：

wait()使线程停止运行，notify()使停止的线程继续运行(随机挑选出一个呈wait状态的线程)。

在调用wait()和notify()前必须获得该对象的对象级别锁，即只能在同步方法或者代码块中调用wait()和notify()方法。

※要等到notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才释放锁，而不是notify()后马上唤醒wait状态的线程进行操作。

(3) sleep():不释放锁；notify():不立即释放锁；wait():释放锁。

(4) 不管线程是wait()还是sleep()状态，调用interrupt()都会抛出InterruptedException异常。只有运行的线程才可被interrupt()。

(5) 唤醒所有等待中的线程：

方法一：多次调用notify()；

方法二：notifyAll()；

(6) 等待wait的条件发生变化：

※用while去判断，while是轮询的，同步的，每一次都会进行判断；而if的话可能有两个线程进去同时进入if语句块就会产生非线程安全问题。

2.生产者/消费者模式实现

多个生产者与消费者：采用wait/notify机制，但不一定每一次唤醒的都是异类，连续唤醒同类就会产生“假死”，以下加粗的地方则为连续唤醒同类。

生产者1  +1

生产者1 wait

生产者2 wait

消费者1  1-1=0

消费者1 wait

消费者2 wait

生产者1 +1

生产者1 wait

生产者2 wait

解决方案1：改为notifyAll();

3. 通过管道进行线程间通信

：一个线程发送数据到输出管道，另一个线程从输入管道中读数据。

3.1 字节流：

PipedInputStream和PipedOutputStreamPipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
out.connect(in);或 in.connect(out);//使两个管道之间进行通信链接

3.2 字符流：PipedReader和PipedWriter，同上connect

4.实例 -- 等待/通知の交叉备份 -- 使线程具有有序性(设置一个volatile参数)package threadservice;

public class DBTools {
volatile private boolean flag = false;
synchronized public void saveA(){
while(flag){
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("save A!");
flag = true;
notifyAll();
}
synchronized public void saveB(){
while(!flag){
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("save B!");
flag = false;
notifyAll();
}
}package threadservice;
public class ThreadA extends Thread{
private DBTools dbtools;
public ThreadA(DBTools dbtools){
this.dbtools = dbtools;
}
@Override
public void run() {
dbtools.saveA();
}
}package threadservice;
public class ThreadB extends Thread{
private DBTools dbtools;
public ThreadB(DBTools dbtools){
this.dbtools = dbtools;
}
@Override
public void run() {
dbtools.saveB();
}
}package threadservice;
public class Run {
public static void main(String[] args) {
DBTools dbtools = new DBTools();
for(int i = 0; i < 3;i++){
ThreadA tA = new ThreadA(dbtools);
tA.start();
ThreadB tB = new ThreadB(dbtools);
tB.start();
}
}
}

打印结果就是交叉打印的，循环等待和通知所有wait线程，但是只有flag正确的那个线程才能运行，即想要顺序执行的话，只要设置参数就可以。save A!

save B!

save A!

save B!

save A!

save B!

5.join()

比如子线程要进行大量的耗时计算，主线程往往早于子线程结束。当主线程需要等待子线程完成之后再结束，就需要用到join()。

如在t1中调用t2.join();t1暂停，必须等到t2运行完才能继续运行。即等待线程对象销毁。

(1) join与synchronized区别：

join()在内部使用wait()方法进行等待，而synchronized使用的是“对象监视器”原理作为同步。

(2) 如果当前线程对象被中断，则当前线程出现异常(只影响当前线程)。

方法join()与interrupt()方法彼此遇到，会出现异常。但影响的是当前的线程，其他线程正常运行。

(3) join(long)和sleep(long)的区别

join(long):在内部使用的是wait(long)，具有释放锁地特点。在内部执行wait(long)后，当前线程的锁被释放，其他线程就可以调用此线程中的同步方法了。

而sleep(long)不释放锁。

(4) 经过运行如下代码发现join后面的代码有可能提前运行，可能会出现以下结果：package jointhread;

public class ThreadA extends Thread {
private ThreadB b;
public ThreadA(ThreadB b) {
super();
this.b = b;
}
@Override
public void run() {
try {
synchronized (b) {
System.out.println("A begins at " + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println("A ends at " + System.currentTimeMillis());
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}package jointhread;
public class ThreadB extends Thread{
@Override
synchronized public void run() {
try {
System.out.println("B begins at " + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println("B ends at " + System.currentTimeMillis());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}package jointhread;
public class Run {
public static void main(String[] args) {
try {
ThreadB b = new ThreadB();
ThreadA a = new ThreadA(b);
a.start();
b.start();
b.join(2000);
System.out.println("main ends at " + System.currentTimeMillis());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

运行结果1：A begins at 1486956475786

A ends at 1486956480825

main ends at 1486956480857

B begins at 1486956480872

B ends at 1486956485880

step1. b.join(2000)先抢到B锁，然后将B锁释放；

step2. ThreadA抢到B锁，打印 A begins 并且sleep(5000)；

step3. ThreadA打印 A ends，并释放锁；

step4. 此时join(2000)和ThreadB争抢锁，而join(2000)再次抢到锁，发现时间已过，释放锁后打印main ends；

step5. ThreadB抢到锁打印B begins；

step6. 5秒之后再打印B ends。

运行结果2：A begins at 1486956475786

A ends at 1486956480825

B begins at 1486956480872

B ends at 1486956485880

main ends at 1486956485880

step1. b.join(2000)先抢到B锁，然后将B锁释放；

step2. ThreadA抢到B锁，打印 A begins 并且sleep(5000)；

step3. ThreadA打印 A ends，并释放锁；

step4. 此时join(2000)和ThreadB争抢锁，而ThreadB抢到锁后执行sleep(5000)后释放锁；

step5. main ends 在最后输出。

运行结果3：A begins at 1486956475786

A ends at 1486956480825

B begins at 1486956480872

main ends at 1486956480872

B ends at 1486956485880

step1. b.join(2000)先抢到B锁，然后将B锁释放；

step2. ThreadA抢到B锁，打印 A begins 并且sleep(5000)；

step3. ThreadA打印 A ends，并释放锁；

step4. 此时join(2000)和ThreadB争抢锁，而join(2000)再次抢到锁，发现时间已过，释放锁后打印main ends；

step5. ThreadB抢到锁打印B begins；

step6. 这时main ends 也异步输出；

step7. 打印B ends。

6.类ThreadLocal

变量值的共享：public static +变量名；

每一个线程都有自己的共享变量：采用类ThreadLocal，使每一个线程绑定自己的值,保证隔离性。

package localthread;
public class Tools {
public static ThreadLocalExt t1 = new ThreadLocalExt();
}package localthread;
import java.util.Date;
public class ThreadLocalExt extends ThreadLocal {
@Override
protected Object initialValue() {
return new Date().getTime();
}
}package localthread;
public class ThreadA extends Thread{
@Override
public void run() {
try {
for(int i = 0;i<10;i++){
System.out.println("ThreadA = " + Tools.t1.get());
Thread.sleep(100);
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}package localthread;
public class Run {
public static void main(String[] args) {
try {
for(int i = 0;i<10;i++){
System.out.println("main =" + Tools.t1.get());
Thread.sleep(100);
}
Thread.sleep(5000);
ThreadA a = new ThreadA();
a.start();
} catch (InterruptedException e) {
// TODO: handle exception
}
}
}

运行结果为10个main打印的值相等，10个ThreadA 打印的值也相等，但main和ThreadA 的不相等。

说明ThreadLocal能够实现一个线程享有一个专属变量。

7.类InheritableThreadLocal

可以在子线程中取得父线程继承下来的值。

(1) 将上例中Tools.java的ThreadLocal改为InheritableThreadLocal，即可得到ThreadA 打印的值和main一样，可谓继承性。

(2) InheritableThreadLocal.childValue(Object object) : 可以修改子线程中的值。

(3) 如果子线程取得值的同时，主线程将InheritableThreadLocal中的值进行修改，子线程拿到的值还是旧值。

三. 线程组

1.作用：可以批量管理线程或线程组对象。

Thread aRunnable = new ThreadA();
ThreadGroup group = new ThreadGroup("小胖的线程组")；
Thread aThread = new Thread(group, aRunnable);

2.在实例化一个线程组如果不指定所属的线程组，则该线程组自动归到当前线程对象所属的线程组中，也就是隐式地在一个线程组中添加了一个子线程组。

JVM的根线程组是system，再取其父线程组则出现异常。

3.递归与非递归取得组内对象。

enumerate(ThreadGroup, true);//递归(打印A->B)
enumerate(ThreadGroup, false);//非递归(只打印A)

4.在默认的情况下，线程组中的一个线程出错，不影响其他线程的运行。