多线程
概念
线程与进程
进程:一个内存中运行的应用程序,每个进程都有独立的内存空间,一个应用程序可以同时运行多个进程;进程也是程序的依次执行过程,是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程,一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。
同步与异步
同步: 排队执行,线程安全,效率低
异步: 同时执行,线程不安全,效率高
比如:A请求某个资源,但是该资源被B占用着,如果同步机制存在,则A将会等待B使用完;如果同步机制不存在,A仍然可以请求B
并行与并发
并行: 同一时间段内,执行多个任务
并发: 同一时刻,执行多个任务
线程调度方式
分时调度: 所有线程轮流使用CPU的使用权,平均分配每个进程占用CPU的时间
抢占式调度: 优先让优先级高的线程使用CPU,如果线程优先级相同,会随机选择一个(线程随机性)。
Java使用的就是抢占式调度
Java中的线程
线程就好比一辆货车,run方法(任务)就相当于货物,把货物**(run)装上货车(Thread)运输到目的地(执行run方法)**
实现方式
继承Thread
通过继承Thread类,实现run方法,调用start方法启动。因为Java是单继承,实现了Thread类就没办法继承其他类。这种方式在继承上略显笨拙。
public class Test {
public static void main(String[] args) {
new MyThread().start();//创建自定义线程对象,调用start()开启
for (int i = 0;i < 10;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"....."+i);
}
}
}
//线程类
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0;i < 10;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"....."+i);
}
}
}
打印结果:
main.....0
Thread-0.....0
Thread-0.....1
main.....1
main.....2
Thread-0.....2
main.....3
Thread-0.....3
Thread-0.....4
main.....4
Thread-0.....5
main.....5
main.....6
Thread-0.....6
Thread-0.....7
main.....7
Thread-0.....8
main.....8
Thread-0.....9
main.....9
main线程和Thread-0线程抢占CPU,谁抢到谁执行
实现Runnable
通过实现Runnable接口,实现他的run方法,调用start方法启动。该方式避免了继承Thread方式的笨拙。
public class Test {
public static void main(String[] args) {
//创建一个任务对象
MyRunnable myRunnable = new MyRunnable();
//将任务装入线程,并开启
new Thread(myRunnable).start();
for (int i = 0;i < 10;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"....."+i);
}
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0;i < 10;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"....."+i);
}
}
}
打印结果:
Thread-0.....0
main.....0
main.....1
Thread-0.....1
Thread-0.....2
main.....2
main.....3
Thread-0.....3
Thread-0.....4
main.....4
Thread-0.....5
main.....5
main.....6
Thread-0.....6
Thread-0.....7
main.....7
main.....8
Thread-0.....8
Thread-0.....9
main.....9
实现Callable
这种方式同前两种不同,实现Callable可以具有返回值,返回给main线程
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建任务
Callable<Integer> callable = new MyCallable();
FutureTask<Integer> task = new FutureTask<>(callable);
//将任务装入线程
new Thread(task).start();
//如果不调用get()则跟前两种线程一样,调用get()后,该线程阻塞,等待执行完后再往下执行
int a = task.get();
System.out.println("返回:"+a);
for (int i = 0;i < 10;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"....."+i);
}
}
}
class MyCallable implements Callable<Integer>{
@Override
public Integer call() throws Exception {
for (int i = 0;i < 10;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"....."+i);
}
return 100;
}
}
打印结果:
Thread-0.....0
Thread-0.....1
Thread-0.....2
Thread-0.....3
Thread-0.....4
Thread-0.....5
Thread-0.....6
Thread-0.....7
Thread-0.....8
Thread-0.....9
返回:100
main.....0
main.....1
main.....2
main.....3
main.....4
main.....5
main.....6
main.....7
main.....8
main.....9
Future接口
- V get()
等待线程执行结束,返回结果 - V get(long timeout, TimeUnit unit)
传一个时间和时间单位,最多等待这些时间,否则抛出超时异常 - boolean isCancelled()
如果任务在执行完前被取消返回true,否则返回false - boolean cancel(boolean mayInterruptIfRunning)
尝试取消该任务 - boolean isDone()
返回 true如果任务已完成
线程状态
在Thread的内部类State中枚举了六种线程的状态
- new(初始状态)
尚未启动的线程处于此状态 - runnable(可运行状态)
在Java虚拟机中执行的线程处于此状态。 - blocked(阻塞状态)
被阻塞等待监视器锁定的线程处于此状态。 - waiting(等待状态)
正在等待另一个线程执行特定动作的线程处于此状态。 - timed_waiting(超时等待)
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。 - terminated
已退出的线程处于此状态。
- 当线程被创建时处于new状态
Thread t = new Thread();
- 当线程被调用start()时,如果获得了cpu的执行时间则是runnable状态;否则进入blocked状态
t.start();
- 当线程处于runnable状态,如果调用了线程对象的wait()、Thread.join()或LockSupport.park()则进入waiting状态
//1. t.wait(); //2. Thread.join(); //3. LockSupport.park();
- 当线程处于runnable状态,如果调用了Thread.sleep(long)、线程对象的wait(long)、Thread.join(long)、LockSupport.parkNanos或LockSupport.parkUntil等方法则进入timed_waiting状态
- 当线程处于runnable状态,如果丢失CPU的执行时间,则进入blocked状态
- 当线程处于runnable状态,run方法执行结束,则进入terminated状态
- 当线程处于timed_waiting状态,如果休眠时间结束或被唤醒,且此时CPU空闲则进入runnable状态,否则进入blocked状态
- 当线程处于waiting状态,调用线程对象的notify()或notifyAll(),则休眠结束,若此时CPU空闲则进入runnable状态,否则进入blocked状态
- 当线程处于blocked状态,如果抢到CPU的执行时间,则进入runnable状态
- 如图所示:
Thread常用方法
- static Thread currentThread()
获取当前线程 - String getName()
获取线程的名称 - void setName(String name)
设置线程的名称 - int getPriority()
获取线程的优先级 - long getId()
获取线程的标识符 - Thread.State getState()
获取线程的状态 - void interrupt()
中断线程,但实际上并不会被中断,只是给线程设置一个中断标志 - static boolean interrupted()
当前线程是否中断,并且可以清除中断标志 - boolean isInterrupted()
该线程是否被中断 - boolean isAlive()
该线程是否存活 - boolean isDaemon()
该线程是否是守护线程
守护线程: 为非守护线程提供服务,依赖与非守护线程 - void join()
在一个线程中调用另一个线程的join(),将等待另一个线程执行完后才继续本线程。 - void join(long millis)
- void join(long millis, int nanos)
- void run()
如果这个线程使用单独的Runnable运行对象构造,则调用该Runnable对象的run方法; 否则,此方法不执行任何操作并返回 - void start()
导致此线程开始执行; Java虚拟机调用此线程的run方法 - static void sleep(long millis)
使当前执行的线程睡眠 - static void yield()
丢弃CPU执行时间,让别的就绪状态线程运行(切换)
线程安全问题
卖票案例:
public class TestTicket {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable);
Thread t2 = new Thread(myRunnable);
Thread t3 = new Thread(myRunnable);
t1.start();
t2.start();
t3.start();
}
}
class MyRunnable implements Runnable{
private int ticket = 10;
@Override
public void run() {
while (true){
if(ticket > 0){
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖出"+(ticket--)+"号票");
}
}
}
}
打印结果:
Thread-0卖出10号票
Thread-1卖出8号票
Thread-2卖出9号票
Thread-1卖出7号票
Thread-2卖出6号票
Thread-0卖出7号票
Thread-0卖出4号票
Thread-1卖出3号票
Thread-2卖出5号票
Thread-2卖出2号票
Thread-0卖出2号票
Thread-1卖出1号票
多个窗口共享10张票,会出现重复卖票或不存在的票
解决方案:
- 同步代码块
public class TestTicket {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable);
Thread t2 = new Thread(myRunnable);
Thread t3 = new Thread(myRunnable);
t1.start();
t2.start();
t3.start();
}
}
class MyRunnable implements Runnable{
private int ticket = 10;
private Object obj = new Object();
@Override
public void run() {
while (true){
synchronized (obj) {
if (ticket > 0) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出" + (ticket--) + "号票");
}
}
}
}
}
打印结果:
Thread-0卖出10号票
Thread-0卖出9号票
Thread-2卖出8号票
Thread-2卖出7号票
Thread-2卖出6号票
Thread-2卖出5号票
Thread-2卖出4号票
Thread-2卖出3号票
Thread-2卖出2号票
Thread-2卖出1号票
- 同步方法
public class TestTicket {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable);
Thread t2 = new Thread(myRunnable);
Thread t3 = new Thread(myRunnable);
t2.start();
t1.start();
t3.start();
}
}
class MyRunnable implements Runnable {
private int ticket = 10;
@Override
public void run() {
while (true) {
sale();
}
}
public synchronized void sale() {
if (ticket > 0) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出" + (ticket--) + "号票");
}
}
}
打印结果:
Thread-1卖出10号票
Thread-1卖出9号票
Thread-1卖出8号票
Thread-0卖出7号票
Thread-0卖出6号票
Thread-2卖出5号票
Thread-2卖出4号票
Thread-2卖出3号票
Thread-2卖出2号票
Thread-2卖出1号票
- Lock
public class TestTicket {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable);
Thread t2 = new Thread(myRunnable);
Thread t3 = new Thread(myRunnable);
t2.start();
t1.start();
t3.start();
}
}
class MyRunnable implements Runnable {
private int ticket = 10;
Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
lock.lock();
if (ticket > 0) {
try {
Thread.sleep(300);
lock.unlock();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出" + (ticket--) + "号票");
} else {
lock.unlock();
break;
}
}
}
}
执行结果:
Thread-2卖出10号票
Thread-1卖出9号票
Thread-0卖出8号票
Thread-2卖出7号票
Thread-1卖出6号票
Thread-0卖出5号票
Thread-2卖出4号票
Thread-1卖出3号票
Thread-0卖出2号票
Thread-2卖出1号票
synchronized关键字
-
修饰代码块,称为同步代码块;
作用范围:大括号内;
作用对象:小括号内的对象
this:该类的实例对象作为锁
xx.class:该类的类对象作为锁
obj:任意类的实例对象作为锁 -
修饰方法,称为同步方法
作用范围:整个方法
作用对象:调用方法的对象 -
修饰静态方法
作用范围:整个静态方法
作用对象:这个类的所有对象
线程间的通信
多个线程在处理同一个资源,但是处理的动作(线程的任务)不相同
为什么要处理线程间通信?
多个线程在并发执行时,在默认情况下CPU是随即切换线程的,当我们需要多个线程来完成一件任务,并且我们希望他们有规律的执行,就需要多个线程协调通信,以此达到多线程共同操作一份数据
如何保证线程间通信有效利用资源:
多个线程操作同一个线程,并且任务不同时,需要线程通信来帮助解决线程之间对同一变量的使用或操作(即多个线程操作一份数据)避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。这种手段就是等待唤醒机制
生产者与消费者
模拟:肯德基与顾客,肯德基生产一个食物,顾客吃一个食物。此时食物就是那个共同的资源,肯德基和顾客则是对公共资源操作的线程。
/**
* 食物
*/
class Food {
private String food;
private boolean have = false;
public Food(String food, boolean have) {
this.food = food;
this.have = have;
}
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
public boolean isHave() {
return have;
}
public void setHave(boolean have) {
this.have = have;
}
}
class KFC extends Thread {
private Food food;
public KFC(Food food) {
this.food = food;
}
@Override
public void run() {
//循环生产food
while (true) {
synchronized (food) {
if (food.isHave()) {//有食物
try {
food.wait();//等着吃没了
} catch (InterruptedException e) {
e.printStackTrace();
}
} //无食物
try {
System.out.println(Thread.currentThread().getName() + "开始生产食物");
Thread.sleep(1000);
food.setHave(true);
food.notify();//唤醒顾客
System.out.println(Thread.currentThread().getName() + food.getFood() + "做好了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class Customer extends Thread {
private Food food;
public Customer(Food food) {
this.food = food;
}
@Override
public void run() {
//一直吃东西
while (true) {
synchronized (food) {
if (!food.isHave()) {//有食物,开吃
try {
food.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "开饭了");
food.setHave(false);
food.notify();//开吃了,等会再做
System.out.println(Thread.currentThread().getName() + "吃没了,再做吧");
}
}
}
}
public class TestTicket {
public static void main(String[] args) {
Food food = new Food("汉堡", true);
Customer customer = new Customer(food);
customer.setName("顾客");
KFC kfc = new KFC(food);
kfc.setName("肯德基");
kfc.start();
customer.start();
}
}
注意:共享的食物对象从头到尾只能是刚开始的那个食物,不能中途new
打印结果:
顾客开饭了
顾客吃没了,再做吧
肯德基开始生产食物
肯德基汉堡做好了
顾客开饭了
顾客吃没了,再做吧
肯德基开始生产食物
肯德基汉堡做好了
顾客开饭了
顾客吃没了,再做吧
肯德基开始生产食物
肯德基汉堡做好了
顾客开饭了
....
线程池
原理:
线程池就是一个容器,当程序第一次启动时,创建多个线程,保存到一个集合,当我们使用时,可以从集合中取出线程使用
优点:
降低资源消耗
提高响应速度
方便管理
分类:
- 缓存线程池
使用时,判断池内是否含有空闲线程,存在则使用;不存在创建线程,放入线程池在使用
public class TestPool {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
};
ExecutorService service = Executors.newCachedThreadPool();
service.execute(runnable);
service.execute(runnable);
service.execute(runnable);
service.execute(runnable);
service.execute(runnable);
}
}
打印结果:
pool-1-thread-1
pool-1-thread-4
pool-1-thread-5
pool-1-thread-2
pool-1-thread-3
- 定长缓存池
使用时,判断池内是否含有空闲线程,存在则使用;不存在,若线程池已满,等待其他线程结束;若线程池不满,创建线程放入线程池在使用
public class TestPool {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
};
ExecutorService service = Executors.newFixedThreadPool(3);
service.execute(runnable);
service.execute(runnable);
service.execute(runnable);
service.execute(runnable);
service.execute(runnable);
}
}
打印结果:
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
- 单线程线程池
使用时,判断线程池的线程是否空闲,空闲则使用,不空闲则等待
public class TestPool {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
};
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(runnable);
service.execute(runnable);
service.execute(runnable);
service.execute(runnable);
service.execute(runnable);
}
}
打印结果:
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
- 周期性任务定长线程池
周期任务:定长线程池
使用时,判断线程池的线程是否空闲,存在则使用;不存在,若线程池已满,等待其他线程结束;若线程池不满,创建线程放入线程池在使用
public class TestPool {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
};
/**
* 定时执行一次
* 任务,时间数,时间单位
*/
ExecutorService service = Executors.newScheduledThreadPool(3);
((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);
((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);
((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);
((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);
((ScheduledExecutorService) service).schedule(runnable,2, TimeUnit.SECONDS);
}
}
打印结果:
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
周期性任务执行时:
定时执行,当某个时机触发时,自动执行某任务
public class TestPool {
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
};
/**
* 定时执行一次
* 任务,延迟时间,周期时间数,时间单位
*/
ExecutorService service = Executors.newScheduledThreadPool(3);
((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);
((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);
((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);
((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);
((ScheduledExecutorService) service).scheduleAtFixedRate(runnable,1,2, TimeUnit.SECONDS);
}
}
打印结果:
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-2
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3