Java 并发基础

2016年03月14日 | Visit count

Thread 类的每一个实例都表示一个线程, 进程是操作系统级别的多任务,JVM 就是运行在一个进程中的。所以在Java 中我我们只考虑线程。进程有独立的内存,一个进程间的多个线程共享进程的内存进程中至少要有一个线程。

线程状态

Concurrent-basis.png

New:当我们创建一个线程时,该线程并没有纳入线程调度,其处于一个new状态。
Runnable:当调用线程的start方法后,该线程纳入线程调度的控制,其处于一个可运行状态,等待分配时间片段以并发运行。
Running:当该线程被分配到了时间片段后其被CPU运行,这是该线程处于running状态。
Blocked:当线程在运行过程中可能会出现阻塞现象,比如等待用户输入信息等。但阻塞状态不是百分百出现的,具体要看代码中是否有相关需求。
Dead:当线程的任务全部运行完毕,或在运行过程中抛出了一个未捕获的异常,那么线程结束,等待GC回收

创建线程

线程有两种创建方式:

方式1:定义一个类并继承Thread,然后重写run方法,在其中书写线程任务逻辑:

Thread t1 = new MyThread1();
Thread t2 = new MyThread2();
t1.start();
t2.start();

class MyThread1 extends Thread {
 public void run() {
 for (int i = 0; i < 5; i++) {
 System.out.println("are you ok?");
 }
 }
}
class MyThread2 extends Thread {
 public void run() {
 for (int i = 0; i < 5; i++) {
 System.out.println("of course");
 }
 }
}

输出:

of course
of course
of course
of course
of course
are you ok?
are you ok?
are you ok?
are you ok?

启动线程要调用start方法,不能直接调用run方法。start方法会将当前线程纳入到线程调度中,使其具有并发运行的能力。start方法很快会执行完毕。当start方法执行完毕后,当前线程的run方法会很快的被执行起来(只要获取到了cpu时间片)。但不能理解为调用start方法时run方法就执行了!

线程有几个不可控因素:

cpu分配时间片给哪个线程我们说了不算。
时间片长短也不可控。
线程调度会尽可能均匀的将时间片分配给多个线程。

第一种创建线程的方式存在两个不足:

由于java是单继承的,这就导致我们若继承了Thread类就无法再继承其他类,这在写项目时会遇到很大问题;
由于我们定义线程的同时重写run方法来定义线程要执行的任务,这就导致线程与任务有一个强耦合关系,线程的重用性变得非常局限。

方式2:定义一个类并实现Runnable接口然后在创建线程的同时将任务指定。因为是实现Runnable接口,所以不影响其继承其他类:

Thread t1 = new Thread(() -> {
 for (int i = 0; i < 5; i++) {
 System.out.println("are you ok?");
 }
});
t1.start();

Thread t2 = new Thread(() -> {
 for (int i = 0; i < 5; i++) {
 System.out.println("of course");
 }
});
t2.start();

线程相关API

获取当前线程:

Thread current = Thread.currentThread(); // Thread[main,5,main]

获取当前线程ID:

1
2

Thread current = Thread.currentThread();
System.out.println(current.getId()); // 1

获取当前线程名字:

1
2

Thread current = Thread.currentThread();
System.out.println(current.getName()); // main

获取当前线程优先级:

1
2

Thread current = Thread.currentThread();
System.out.println(current.getPriority()); // 5

判断当前线程是否还活着:

1
2

Thread current = Thread.currentThread();
System.out.println(current.isAlive()); // true

判断当前线程是否为守护线程:

1
2

Thread current = Thread.currentThread();
System.out.println(current.isDaemon()); // false

判断当前线程是否被中断:

1
2

Thread current = Thread.currentThread();
System.out.println(current.isInterrupted()); // false

线程的优先级

线程优先级分为10个等级,1最低,5默认,10最高。线程提供了3个常量:

MIN_PRIORITY:1 对应最低优先级;
MAX_PRIORITY: 10 对应最高优先级;
NORM_PRIORITY:5 默认优先级。

线程阻塞

Thread提供了一个静态方法: sleep,该方法会阻塞运行当前方法的线程指定毫秒。当超时后,线程会自动回到Runnable状态,等待再次分配时间片运行:

System.out.println("程序开始了");
try {
 Thread.sleep(5000);
} catch (InterruptedException e) {
 e.printStackTrace();
}
System.out.println("程序结束了");

守护线程

后台线程,又叫做守护线程,当一个进程中的所有前台线程都结束了,进程就会结束,无论进程中的其他后台线程是否还在运行,都要被强制中断:

Thread front = new Thread(() -> {
 for (int i = 0; i < 2; i++) {
 System.out.println("前端线程运行中");
 try {
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 System.out.println("前台线程运行完毕");
});

Thread back = new Thread(() -> {
 while (true) {
 System.out.println("前台线程结束,我就gg");
 try {
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
});

front.start();
back.setDaemon(true);
back.start();

输出如下:

前台线程结束,我就gg
前端线程运行中
前台线程结束,我就gg
前端线程运行中
前台线程结束,我就gg
前台线程运行完毕

yield

该方法用于使当前线程主动让出当次CPU时间片回到Runnable状态,等待分配时间片。

join

允许当前线程在另一个线程上等待,直到另一个线程结束工作。通常是用来协调两个线程工作使用:

private static boolean isFinish = false;

public static void main(String[] args) {
 Thread download = new Thread(() -> {
 System.out.println("开始下载图片...");
 for (int i = 1; i <= 100; i++) {
 System.out.println("down:" + i + "%");
 try {
 TimeUnit.MILLISECONDS.sleep(10);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 System.out.println("图片下载完毕!");
 isFinish = true;
 });

 Thread show = new Thread(() -> {
 System.out.println("开始显示图片...");
 try {
 download.join();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 if (!isFinish) {
 throw new RuntimeException("图片加载失败!");
 }
 System.out.println("图片显示完毕!");
 });
 download.start();
 show.start();
}

thread-join.gif

synchroinzed

多个线程并发读写同一个临界资源时候会发生"线程并发安全问题"

常见的临界资源:

多线程共享实例变量;
多线程共享静态公共变量。

若想解决线程安全问题,需要将异步的操作变为同步操作。何为同步?那么我们来对比看一下什么是同步什么异步:

所谓异步操作是指多线程并发的操作,相当于各干各的。
所谓同步操作是指有先后顺序的操作,相当于你干完我再干。

而java中有一个关键字名为:synchronized,该关键字是同步锁,用于将某段代码变为同步操作,从而解决线程并发安全问题。使用锁需要注意两个方面:

选择合适的锁对象:使用synchroinzed需要对一个锁对象上锁以保证线程同步。那么这个锁对象应当注意多个需要同步的线程在访问该同步块时,看到的应该是同一个锁对象引用。否则达不到同步效果。通常我们会使用this来作为锁对象。
选择合适的锁范围:在使用同步块时,应当尽量在允许的情况下减少同步范围,以提高并发的执行效率。

synchronized关键字有两个用法:

修饰方法,这样的话,该方法就称为"同步方法",多个线程就不能同时进入到方法内部去执行。可以避免由于线程切换不确定,导致的逻辑错误。
synchronized块,可以将某段代码片段括起来,多个线程不能同时执行里面的代码。

public static void main(String[] args) {
 final Table table = new Table();
 Thread t0 = new Thread() {
 public void run() {
 while (true) {
 int bean = table.getBean();
 Thread.yield();
 System.out.println(getName() + ":" + bean);
 }
 }
 };
 Thread t1 = new Thread() {
 public void run() {
 while (true) {
 int bean = table.getBean();
 Thread.yield();
 System.out.println(getName() + ":" + bean);
 }
 }
 };
 t0.start();
 t1.start();
}

static class Table {
 private int beans = 20;
 synchronized int getBean() {
 if (beans == 0) {
 throw new RuntimeException("没有豆子了!");
 }
 Thread.yield();
 return beans--;
 }
}

如果不加synchronized关键字,可能beans为负数了,线程还在执行,成了死循环。

synchronized块的例子:

public static void main(String[] args) {
 final Shop shop = new Shop();
 Thread t1 = new Thread(shop::buy);
 Thread t2 = new Thread(shop::buy);
 t1.start();
 t2.start();
}

static class Shop {
 void buy() {
 try {
 Thread t = Thread.currentThread();
 System.out.println(t + "正在挑选衣服.");
 Thread.sleep(1000);
 synchronized (this) {
 System.out.println(t + "正在试衣服.");
 Thread.sleep(1000);
 }

 System.out.println(t + "结账离开.");
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
}

此时,"正在试衣服"这个代码块一次只能一个线程执行。

wait&notify

Object类中定义了两个方法wait()和notify()。它们也可以实现协调线程之间同步工作的方法。当一个线程调用了某个对象的wait方法时,这个线程就进入阻塞状态,直到这个对象的notify方法被调用,这个线程才会解除wait阻塞,继续向下执行代码。

若多个线程在同一个对象上调用wait方法进入阻塞状态后,那么当该对象的notify方法被调用时,会随机解除一个线程的wait阻塞,这个不可控。若希望一次性将所有线程的wait阻塞解除,可以调用notifyAll方法。

private static boolean isFinish;
private static final Object obj = new Object();

public static void main(String[] args) {
 final Thread download = new Thread(() -> {
 System.out.println("down:开始下载图片...");
 for (int i = 1; i <= 100; i++) {
 System.out.println("down:" + i + "%");
 try {
 TimeUnit.MILLISECONDS.sleep(10);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 System.out.println("down:图片下载完毕!");
 isFinish = true;
 //通知 show线程开始工作
 synchronized (obj) {
 obj.notify();
 }
 });

 Thread show = new Thread(() -> {
 System.out.println("show:开始显示图片...");
 synchronized (obj) {
 try {
 obj.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }

 if (!isFinish) {
 throw new RuntimeException("图片加载失败!");
 }
 System.out.println("show:图片显示完毕!");
 });
 download.start();
 show.start();
}

thread-wait-notify.gif

线程池

当我们的逻辑中出现了会频繁创建线程的情况时,就要考虑使用线程池来管理线程。这可以解决创建过多线程导致的系统威胁。

线程池主要解决两个问题:

控制线程数量;
重用线程。

//创建一个固定大小的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(3);

//指派 5个任务
for (int i = 0; i < 5; i++) {
 Runnable runn = () -> {
 Thread t = Thread.currentThread();
 System.out.println(t + "正在运行任务!");
 try {
 TimeUnit.SECONDS.sleep(2);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println(t + "执行任务完毕");
 };
 threadPool.execute(runn);
}
//停止线程池
threadPool.shutdown();

Thread[pool-1-thread-2,5,main]正在运行任务!
Thread[pool-1-thread-1,5,main]正在运行任务!
Thread[pool-1-thread-3,5,main]正在运行任务!
Thread[pool-1-thread-2,5,main]执行任务完毕
Thread[pool-1-thread-3,5,main]执行任务完毕
Thread[pool-1-thread-2,5,main]正在运行任务!
Thread[pool-1-thread-1,5,main]执行任务完毕
Thread[pool-1-thread-3,5,main]正在运行任务!
Thread[pool-1-thread-3,5,main]执行任务完毕
Thread[pool-1-thread-2,5,main]执行任务完毕

此时同时只能有三个线程数量。

请作者喝瓶肥宅水🥤

MrBird WeChat Pay

MrBird Alipay

本文作者: MrBird
本文链接: http://mrbird.cc/Java-Concurrent-Basis.html
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明出处!