概念
线程的生命周期
线程的状态定义在 java.lang.Thread.State 中
NEW
创建状态并未执行,通过start()方法开始线程执行,进入RUNNABLE
RUNNABLE
运行状态
BLOCKED
阻塞状态,如果在执行的过程中遇到了synchronize 关键字标注的同步块,就会进入阻塞状态
WAITING
等待状态,表示线程进入了等待状态,直到notify()方法执行通知后,线程继续进入运行状态
TIMED_WAITING
等待状态,同上一样,只不过加上了一个等待的时间限制.
TERMINATED
终止状态
线程的基本操作
新建线程与启动
主线程
package t;
public class M {
public static void main(String[] args) {
Thread t = new Thread(new MyThread());
//t.start();
t.run();
for(int i = 0 ;i < 5 ; i++){
System.out.println("main : " + i);
}
}
}
子线程
package t;
public class MyThread implements Runnable{
@Override
public void run() {
for(int i = 0 ; i < 5 ; i++){
System.out.println("other : " + i);
}
}
}
注意:启动方法时start ,而不是 run 。 如果通过run就是串行话的调用,打印结果永远都是
other : 0
other : 1
other : 2
other : 3
other : 4
main : 0
main : 1
main : 2
main : 3
main : 4
而使用start才是开启线程,打印结果随机产生,是因为线程的执行情况,有时候主线程执行的比较快,也适合子线程执行的比较快
线程终止
正常情况下,线程执行完毕就会终止,不用手动关闭。
但是有时候也会有一些情况下是有例外的,比如线程本身就在一个无限循环里面执行
关闭线程在jdk中提供了一个stop方法,但是这个方法已经过时了,因为这个方法太暴力,直接关闭线程,不管线程是否执行完毕。
线程同步synchronize
//打印类
public class Print {
public synchronized void prt(){
for(int i = 0 ; i < 5 ; i++){
System.out.println(Thread.currentThread().getName() + " : " + i);
}
}
}
//线程类
public class Th1 implements Runnable{
private Print p;
public Th1(Print p) {
this.p = p;
}
@Override
public void run() {
p.prt();
}
}
//Main方法类
public class M {
public static void main(String[] args) {
Print p = new Print();
new Thread(new Th1(p)).start();
new Thread(new Th1(p)).start();
}
}
上面这段代码 直接执行 打印结果 如下,ID并不连续,一会打印线程9 ,一会打印 线程10
Thread-0 : 0
Thread-1 : 0
Thread-0 : 1
Thread-1 : 1
Thread-0 : 2
Thread-1 : 2
Thread-0 : 3
Thread-1 : 3
Thread-0 : 4
Thread-1 : 4
而给 Print类的prt 方法 加上 synchronized 后 发现 打印是非常规律的,一个线程完全打印完毕,才会打印另外一个线程,也意味着 一个线程执行完毕,另外一个线程才能进行执行
等待与通知
在调用wait的时候,线程自动释放其占有的对象锁,同时不会去申请对象锁。当线程被唤醒的时候,它才再次获得了去获得对象锁的权利。
notify唤醒在等待该对象同步锁的线程(只唤醒一个,如果有多个在等待),注意的是在调用此方法的时候,并不
能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级
notifyAll唤醒所有等待的线程
package c;
public class MyThreadFactory {
public static void main(String[] args) {
MyThreadFactory factory = new MyThreadFactory();
factory.startThreadA();
factory.startThreadB();
factory.startThreadC();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
factory.startWakenThread();
}
public MyThreadFactory() {
}
/**
* 对象锁
*/
private final Object object = new Object();
/**
* 该线程作为一个唤醒线程
*/
public void startWakenThread() {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
synchronized (object) {
System.out.println("唤醒线程开始执行...");
// 首先释放线程A
quitThreadA();
}
}
});
t.start();
}
/**
* 启动线程A
*/
public void startThreadA() {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
synchronized (object) {
System.out.println("线程A开始等待...");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程A结束...");
// 线程A结束后,暂停2秒释放线程B
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
quitThreadB();
}
}
});
t.start();
}
/**
* 启动线程B
*/
public void startThreadB() {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
synchronized (object) {
System.out.println("线程B开始等待...");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程B结束...");
// 线程B结束后,暂停2秒释放线程C
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
quitThreadC();
}
}
});
t.start();
}
/**
* 启动线程C
*/
public void startThreadC() {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
synchronized (object) {
System.out.println("线程C开始等待...");
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程C结束...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("所有线程执行完毕!");
}
}
});
t.start();
}
/**
* 线程A退出等待
*/
private void quitThreadA() {
object.notify();
}
/**
* 线程B退出等待
*/
private void quitThreadB() {
object.notify();
}
/**
* 线程C退出等待
*/
private void quitThreadC() {
object.notify();
}
}
等待线程结束(join)和谦让(yield)
join表示在两个线程执行的过程中A线程执行某一项工作,B线程执行一项工作依赖A线程执行初始化完毕之后才能开始执行,则可以用的join
yield表示当前线程让出cpu执行,但是让出线程之后不代表这个线程就不执行了,而是由当前线程与其他线程进行资源的抢夺,当前线程能否再次被分配到就是随机的
线程的优先级
/**
* The minimum priority that a thread can have.
*/
public final static int MIN_PRIORITY = 1;
/**
* The default priority that is assigned to a thread.
*/
public final static int NORM_PRIORITY = 5;
/**
* The maximum priority that a thread can have.
*/
public final static int MAX_PRIORITY = 10;