Java入门系列-21-多线程

什么是线程

在操作系统中,一个应用程序的执行实例就是进程,进程有独立的内存空间和系统资源,在任务管理器中可以看到进程。

线程是CPU调度和分派的基本单位,也是进程中执行运算的最小单位,可完成一个独立的顺序控制流程,当然一个进程中可以有多个线程。

多线程:一个进程中同时运行了多个线程,每个线程用来完成不同的工作。多个线程交替占用CPU资源,并非真正的并行执行。

使用多线程能充分利用CPU的资源,简化编程模型,带来良好的用户体验。

一个进程启动后拥有一个主线程,主线程用于产生其他子线程,而且主线程必须最后完成执行,它执行各种关闭动作。

在Java中main()方法为主线程入口,下面使用 Thread 类查看主线程名。

public class MainThread {
	public static void main(String[] args) {
		//获取当前线程
		Thread t=Thread.currentThread();
		System.out.println("当前线程名字:"+t.getName());
		//自定义线程名字
		t.setName("MyThread");
		System.out.println("当前线程名字:"+t.getName());
	}
}

创建线程

在Java中创建线程有两种方式
1.继承 java.lang.Thread 类
2.实现 java.lang.Runnable 接口

1.继承 Thread 类创建线程

(1)定义MyThread类继承Thread类

(2)重写run()方法,编写线程执行体

public class MyThread extends Thread{

	//重写run方法
	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

(3)创建线程对象,调用start()方法启动线程

public class TestMyThread {

	public static void main(String[] args) {
		MyThread myThread=new MyThread();
		//启动线程
		myThread.start();
	}
}

多个线程同时启动后是交替执行的,线程每次执行时长由分配的CPU时间片长度决定

修改 TestMyThread.java 观察多线程交替执行

public class TestMyThread {

	public static void main(String[] args) {
		MyThread myThread1=new MyThread();
		MyThread myThread2=new MyThread();
		myThread1.start();
		myThread2.start();
	}
}

多运行几次观察效果

启动线程能否直接调用 run()方法?
不能,调用run()方法只会是主线程执行。调用start()方法后,子线程执行run()方法,主线程和子线程并行交替执行。

2.实现 Runnable 接口创建线程

(1)定义MyRunnable类实现Runnable接口

(2)实现run()方法,编写线程执行体

public class MyRunnable implements Runnable{
    //实现 run方法
	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

(3)创建线程对象,调用start()方法启动线程

public class TestMyRunnable {

	public static void main(String[] args) {
		Runnable runnable=new MyRunnable();
		//创建线程,传入runnable
		Thread t=new Thread(runnable);
		t.start();
	}
}

线程的生命周期

启动线程
阻塞解除
释放CPU资源
获得CPU资源
等待用户输入线程休眠等
创建状态
就绪状态
阻塞状态
运行状态
死亡状态

创建状态:线程创建完成,比如 MyThread thread=new MyThread

就绪状态:线程对象调用 start() 方法,线程会等待CPU分配执行时间,并没有立马执行

运行状态:线程分配到了执行时间,进入运行状态。线程在运行中发生礼让 (yield) 会回到就绪状态

阻塞状态:执行过程中遇到IO操作或代码 Thread.sleep(),阻塞后的线程不能直接回到运行状态,需要重新进入就绪状态等待资源的分配。

死亡状态:自然执行完毕或外部干涉终止线程

线程调度

线程调度指按照特定机制为多个线程分配CPU的使用权

线程调度常用方法

方法说明
setPriority(int newPriority)更改线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()等待该线程终止
static void yield()暂停当前正在执行的线程对象,并执行其他线程
void interrupt()中断线程
boolean isAlive()测试线程是否处于活动状态

线程优先级的设置

线程优先级由1~10表示,1最低,默认有限级为5。优先级高的线程获得CPU资源的概率较大。

public class TestPriority {

	public static void main(String[] args) {
		Thread t1=new Thread(new MyRunnable(),"线程A");
		Thread t2=new Thread(new MyRunnable(),"线程B");
		//最大优先级
		t1.setPriority(Thread.MAX_PRIORITY);
		//最小优先级
		t2.setPriority(Thread.MIN_PRIORITY);
		t1.start();
		t2.start();
	}
}

线程休眠

让线程暂时睡眠指定时长,线程进入阻塞状态,睡眠时间过后线程会再进入可运行状态。

休眠时长以毫秒为单位,调用sleep()方法需要处理 InterruptedException异常。

public class TestSleep {
	
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			System.out.println("第 "+i+" 秒");
			try {
				//让当前线程休眠1秒
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

强制运行

使用 join() 方法实现,可以认为是线程的插队,会先强制执行插队的线程。

public class JoinThread implements Runnable{

	@Override
	public void run() {
		for (int i = 1; i <=10; i++) {
			System.out.println("线程名:"+Thread.currentThread().getName()+" i:"+i);
		}
		System.out.println("插队线程执行完毕!");
	}	
}
public class TestJoin {

	public static void main(String[] args) {
		Thread joinThread=new Thread(new JoinThread(),"插队的线程");
		//启动后与主线程交替执行
		joinThread.start();
		for (int i = 1; i <= 10; i++) {
			if (i==5) {
				try {
					System.out.println("====开始插队强制执行====");
					joinThread.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("线程名:"+Thread.currentThread().getName()+" i:"+i);
		}
		System.out.println("主线程执行完毕!");
	}
}

最一开始执行,主线程 main 和 "插队的线程"是交替执行。当主线程的循环到第5次的时候,调用 "插队的线程"的join方法,开始强制执行"插队的线程",待"插队的线程"执行完后,才继续恢复 main 线程的循环。

线程礼让

使用 yield() 方法实现,礼让后会暂停当前线程,转为就绪状态,其他具有相同优先级的线程获得运行机会。

下面我们实现Runnable接口,在run方法中实现礼让,创建两个线程,达到某种条件时礼让。

public class YieldThread implements Runnable{

	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			System.out.println("线程名:"+Thread.currentThread().getName()+" i:"+i);
			//当前线程执行到5后发生礼让
			if (i==5) {
				System.out.println(Thread.currentThread().getName()+" 礼让:");
				Thread.yield();
			}
		}
	}
}
public class TestYield {

	public static void main(String[] args) {
		Thread t1=new Thread(new YieldThread(),"A");
		Thread t2=new Thread(new YieldThread(),"B");
		t1.start();
		t2.start();
	}
}

只是提供一种可能,不能保证一定会实现礼让

线程同步

首先看一个多线共享同一个资源引发的问题

仓库有10个苹果,小明、小红、小亮每次可以从仓库中拿1个苹果,拿完苹果后仓库中的苹果数量-1。

先编写仓库资源类,实现接口

//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
	private int num=10;
	@Override
	public void run() {
		while(true) {
			if (num<=0) {
				break;
			}
			num--;
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"拿走一个,还剩余:"+num);
		}
	}
}

编写测试类,创建两个线程对象,共享同一个资源

public class TestResource {

	public static void main(String[] args) {
		ResourceThread resource=new ResourceThread();
		//使用同一个Runnable实现类对象
		Thread t1=new Thread(resource,"小明");
		Thread t2=new Thread(resource,"小红");
		Thread t3=new Thread(resource,"小亮");
		t1.start();
		t2.start();
		t3.start();
	}
}

运行后我们发现,每次拿完苹果后的剩余数量出现了问题,使用同步方法可以解决这个问题。

语法:

访问修饰符 synchronized 返回类型 方法名(参数列表){
    ……
}

synchronized 就是为当前的线程声明一个锁

修改 ResourceThread.java 实现同步

//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
	private int num=10;
	private boolean isHave=true;
	@Override
	public void run() {
		while(isHave) {
			take();
		}
	}
	//同步方法
	public synchronized void take() {
		if (num<=0) {
			isHave=false;
			return;
		}
		num--;
		try {
			Thread.sleep(300);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"拿走一个,还剩余:"+num);
	}
}

实现同步的第二种方式同步代码块

语法:

synchronized(syncObject){
    //需要同步的代码
}

syncObject为需同步的对象,通常为this

修改 ResourceThread.java 改为同步代码块

//这个实现类将被多个线程对象共享
public class ResourceThread implements Runnable{
	private int num=10;
	private boolean isHave=true;
	@Override
	public void run() {
		while(isHave) {
			synchronized(this) {
				if (num<=0) {
					isHave=false;
					return;
				}
				num--;
				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"拿走一个,还剩余:"+num);				
			}
		}
	}
}

-公告-

热门文章

友情链接