这里写目录标题
Java的线程
了解线程需要先了解进程与线程的关系。
进程:一个可运行的完整的程序代码,是由cpu分配运行资源直到从发展到消亡的过程。
一个进程中存在多个同时运行的线程。
线程:可运行的一段代码,是由5个状态进行的,多个线程组成一个进程。
实现线程的方式
1、继承Thread类
2、实现Runnable接口
线程的状态变化
操作系统层的线程具有5种状态: 创建、就绪、运行、阻塞、终止。
1、创建:在程序用构造方法创建一个线程对象后,线程类就处于新建状态,就已经拥有内存空间和其他资源,但还处于不可运行状态。
2、就绪:就是让线程进入cpu的队列内进行等待,这样就具备可运行的条件,即调用start()。
3、运行:就是cpu分配好资源,自动调用run,执行线程的操作与功能。
4、阻塞:这是一个特殊情况下的状态,如果线程被人为挂起或输出输入超时,线程会被暂停,
如 sleep(),wait(),suspend()等都会进入阻塞,且阻塞的线程不能进入队列,只有阻塞被消除后,
才能进行进入就绪(cpu队列)。
5、终止:线程调用stop()或者run()方法运行完成,程序不再具备可以运行的能力。
java线程有6种状态。
分别为创建、运行中(将操作系统的就绪和运行)统一称为运行中、阻塞、等待(无线等待,需要中断操作)、计时等待(超时自动返回)、终止。
线程的操作
一、join()
线程的让步,其他线程要先等待该线程运行完成后,才可以继续运行。
public static void method01(){
JoinThread j1 = new JoinThread();
Thread t1 = new Thread(j1,"线程A");
t1.start();
for (int i = 0; i < 5; i++) {
if (i > 2){
try {
t1.join();//强制让t1线程先运行完成后,其他线程才能继续运行。
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("主线程运行,1 = " + i);
}
}
/* join */
class JoinThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "运行,i = " + i);
}
}
}
结果输出
二、sleep()
线程的休眠,让线程进入到阻塞状态,让出cpu资源,重新回到队列。
for (int i = 0; i < 50; i++) {
try {
//休眠2秒
sleep(2000);
}catch (InterruptedException e){
e.printStackTrace();
}
三、interrupt()
线程的中断。interrupt() 方法只会中断线程的阻塞状态,并抛出中断异常,不会直接打断正在运行中的线程。如要中断正在 sleep() 状态的子线程 t1 ,在正在运行的另一条线程中调用 t1.interrupt() 即可中断 t1 。
public static void method03(){
InterruptThread i1 = new InterruptThread();
Thread t1 = new Thread(i1,"线程Q");
t1.start();
try {
Thread.sleep(5000);
}catch (Exception e){
e.printStackTrace();
}
t1.interrupt();//中止t1线程运行
}
/*
* interrupt
* */
class InterruptThread implements Runnable{
@Override
public void run() {
try {
System.out.println("进入到run运行");
for (int i = 0; i < 50; i++) {
if (i == 20) {
Thread.sleep(10000);
System.out.println("线程休眠结束");
}
System.out.println(Thread.currentThread().getName() + "运行,i = " + i);
}
System.out.println("线程运行完成");
}catch (Exception e){
System.out.println("线程被中断");
}
}
}
setDaemon()
后台线程,当java线程结束后,让线程在后台完成运行
t1.setDaemon(true);//线程在后台运行
t1.start();
priority()
线程的优先级 1 - 10,数字越高,优先级越高,默认优先级为5。
优先级高会大概率先执行,但只是执行频率更高,不是一定比优先级低的先执行
t1.setPriority(1);
t2.setPriority(5);
t3.setPriority(10);
t1.start();
t2.start();
t3.start();
yield()
线程的礼让,先让其他线程运行。
使用yield()方法会使当前线程从运行状态变成就绪状态。
cpu的程序会在就绪线程中随机选取一条线程,所以礼让是概率事件,不一定会成功。
public static void method06(){
YieldThread y1 = new YieldThread();
new Thread(y1,"线程A").start();
new Thread(y1,"线程B").start();
new Thread(y1,"线程C").start();
}
/* yield */
class YieldThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(500);
}catch (Exception e){
e.printStackTrace();
}
String name = Thread.currentThread().getName();
System.out.println(name + "运行,i = " + i);
if (i >= 5 && name.equals("线程A")){
System.out.println(name + ":我礼让我快乐");
Thread.currentThread().yield();
}
}
}
}
输出结果
结果输出中线程A的礼让过程分别是不成功和成功。
wait()
作用是让当前线程进入等待状态,同时也会让当前线程释放它所持有的锁。
notify()
当前的线程已经放弃对资源的占有,通知等待的线程来获得对资源的占有权,但是只有一个线程能够从wait状态中恢复
线程的锁机制
线程的同步锁
线程的同步锁:synchronize
synchronize(同步对象){
//需要同步的代码
}
synchronize void method(){
//需要同步的代码
}
线程的死锁
死锁产生的原因通常是多个线程同时访问共享数据时造成冲突。
产生死锁的四个必要条件:
1、互斥条件:
一个资源每次只能被一个进程(线程)使用。
2、占有和等待条件:
已经分配给某个资源的线程可以请求新的资源。
3、不可抢占条件:
已经分配给一个进程的资源不能强行地被抢占,它只能占有它的进程显示的释放。
4、循环等待条件:
系统中一定有两个或者两个以上的进程组成一条环路,该环路中的每一个进程都在等待着下一个进程所占有的资源。
public static void main(String[] args) {
DeadLockThread d1 = new DeadLockThread();
DeadLockThread d2 = new DeadLockThread();
d1.flat = true;
d2.flat = false;
new Thread(d1).start();
new Thread(d2).start();
}
class Person1{
public void say(){
System.out.println("P1对P2说,你放手,我就放手");
}
public void result(){
System.out.println("P2松开了手");
}
}
class Person2{
public void say(){
System.out.println("P2对P1说,你放手,我就放手");
}
public void result(){
System.out.println("P1松开了手");
}
}
class DeadLockThread implements Runnable{
private static Person1 p1 = new Person1();
private static Person2 p2 = new Person2();
public boolean flat = false;
@Override
public void run() {
//死锁实现流程
if (flat) {
synchronized (p1) {//1、p1执行,p1{}内容被锁
p1.say();
try {
Thread.sleep(500);// 2、因为进入睡眠,2线程执行
} catch (Exception e) {
e.printStackTrace();
}
synchronized (p2){//4、因为p2被锁,所以无法执行
p1.result();
}
}
}else{
synchronized (p2) {//3、p2执行,p2{}内容被锁
p2.say();
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (p1){//5、因为p1被锁,无法执行
p2.result();
}
}
}
}
}
需要注意的是:
静态对象的数据是全局共享的,同个类的每个静态对象都会共享同一数据,而普通对象的数据都是独立的。
锁静态对象时所有实例运行到该处都会被锁住(类级别的锁),而锁实例对象的时候,该锁只对每个实例有效(实例级别的锁) 。
所以如果该锁静态对象的时候,锁了实例对象,会造成该锁无效;如果在该锁实例对象的时候,锁了静态对象,会造成很大的性能问题。