一、并发基础
1. 多线程的作用
平衡CPU、内存、I/O设备的速度差异,合理利用CPU的高性能
- CPU增加了缓存,来均衡与内存的速度差异 (导致可见性问题)
- 操作系统增加了进程、线程,以分时复用CPU来均衡CPU与I/O设备的速度差异(导致原子性问题)
- 编译程序优化指令执行次序,使得缓存能够更加合理的运用 (导致有序性问题)
2. 并发三要素
可见性: 一个线程对共享变量的修改,另外一个线程能够立刻看到(CPU缓存引起不可见性)
原子性: 多个操作 要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行。(分时复用引起)
有序性: 程序执行的顺序按照代码的先后顺序执行 (指令重排会打乱顺序)
3. Java 原子性保证
Java内存模型只保证了基本读取和简单赋值(如a = 10)操作是原子性的,其他实现需要通过synchronized和Lock来实现。由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块,那么自然就不存在原子性问题了,从而保证了原子性。
4. Java可见性保证
Java提供了volatile关键字来保证可见性。当一个共享变量被volatile
修饰时,它会保证修改的值会立即被更新到主存,当有其他线程需要读取时,它会去内存中读取新值。
而普通的共享变量不能保证可见性,因为普通共享变量被修改之后,什么时候被写入主存是不确定的,当其他线程去读取时,此时内存中可能还是原来的旧值,因此无法保证可见性。
通过synchronized
和Lock
也能够保证可见性,synchronized
和Lock
能保证同一时刻只有一个线程获取锁然后执行同步代码,并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性
5. Java有序性保证
synchronized
和Lock
synchronized
和Lock
保证每个时刻是有一个线程执行同步代码,相当于是让线程顺序执行同步代码,自然就保
证了有序性。当然JMM是通过Happens-Before
规则来保证有序性的。
二、线程基础
1. Java中线程的使用方式
有三种使用线程的方法:实现 Runnable 接口;实现 Callable 接口;继承 Thread 类。
实现Runnable接口的例子:
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
public static class MyRunnable implements Runnable{
@Override
public void run() {
}
}
实现Callable接口的例子:
public class Test {
public static void main(String[] args) {
MyCallable myCallable = new MyCallable();
FutureTask<String> futureTask = new FutureTask<>(myCallable);
Thread thread = new Thread(futureTask);
thread.start();
try {
// 获取返回结果
System.out.println(futureTask.get());
} catch (Exception e) {
e.printStackTrace();
}
}
public static class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
return "ok";
}
}
}
继承Thread类
public class Test {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
public static class MyThread extends Thread{
@Override
public void run() {
super.run();
}
}
}
实现 Runnable
和 Callable
接口的类只能当做一个可以在线程中运行的任务,不是真正意义上的线程,因此最后还需要通过 Thread
来调用。可以说任务是通过线程驱动从而执行的
Runnable
和Callable
的区别
Callable
可以有返回值,返回值通过 FutureTask
进行封装。
当调用 start()
方法启动一个线程时,虚拟机会将该线程放入就绪队列中等待被调度,当一个线程被调度时会执行该线程的run()
方法。
如何选择,实现接口更好,因为Java不支持多继承,如果继承Thread
类就不能继承其他类了,接口也更轻量。实际上Thread
类以也实现了Runnable
2. Daemon守护线程
守护线程是程序运行时在后台提供服务的线程,不属于程序中不可或缺的部分。
当所有非守护线程结束时,程序也就终止,同时会杀死所有守护线程。main()
属于非守护线程。
使用 setDaemon()
方法将一个线程设置为守护线程。
public static void main(String[] args) {
Thread thread = new Thread();
thread.setDaemon(true);
}
3. sleep()
Thread.sleep(millisec)
方法会休眠当前正在执行的线程,millisec
单位为毫秒。
sleep()
可能会抛出 InterruptedException
,因为异常不能跨线程传播回 main()
中,所以必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
4. join()
在线程中调用另一个线程的join()
方法,会将当前线程挂起,而不是忙等待,直到目标线程结束
5. wait() notify() notifyAll()
调用wait()
使得线程等待某个条件满足,线程在等待时会被挂起,当其他线程的运行使得这个条件满足时,其它线程会调用notify()
或者notifyAll()
来唤醒挂起的线程。
它们都属于 Object
的一部分,而不属于 Thread
。
只能用在同步方法或者同步控制块中,否则会在运行时抛出 IllegalMonitorStateExeception
。
使用wait()
挂起期间,线程会释放锁。这是因为,如果没有释放锁,那么其它线程就无法进入对象的同步方法或者同步控制块中,那么就无法执行notify()
或者notifyAll()
来唤醒挂起的线程,造成死锁。
6. wait() 和 sleep() 的区别
wait()
是Object
的方法,而sleep()
是Thread
的静态方法;wait()
会释放锁,sleep()
不会。
7. await() signal() signalAll()
java.util.concurrent
类库中提供了 Condition
类来实现线程之间的协调,可以在 Condition
上调用await()
方法使线程等待,其它线程调用 signal()
或 signalAll()
方法唤醒等待的线程。相比于wait()
这种等待方式,await()
可以指定等待的条件,因此更加灵活。
使用 Lock
来获取一个 Condition
对象。