1.1 线程的生命周期
| 方法名 | 说明 |
|---|---|
| yield() | |
| stop() | |
| sleep() | |
| wait() | 阻塞 |
| suspend() | 挂起 |
| notify()/notifyAll() | 唤醒 |
| resume() | 取消挂起 |
1.2 线程的安全问题
1.2.1 通过同步机制解决线程安全问题
方式一：同步代码块
synchronized(同步监视器) {
//需要被同步的代码
}
class Window implements Runnable {
private int tickets = 100;
private Object obj = new Object();//多线程共用同一把锁，即是同步监视器
@Override
public void run() {
while (true) {
synchronized (obj) {
if (tickets > 0) {
System.out.println("售票，票号为:" + tickets);
tickets--;
} else {
break;
}
}
}
}
}
说明：操作共享数据的代码，即为需要被同步的代码。
同步监视器，俗称锁。任何类的对象，都可以充当锁。但要求多个线程必须共用同一把锁。在实现Runnable接口创建多线程的方式中，可以考虑使用this充当同步监视器。在继承Thread创建多线程的方式中，可以使用当前类(Bank.class)充当同步监视器，类本身也是一个对象。
方式二：同步方法
1.同步方法解决实现Runnable接口的线程创建方式的线程安全问题
@Override
public void run() {
while(true) {
show();
}
}
private synchronized void show() {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName() + "售票，票号为:" + tickets);
tickets--;
}
此时同步方法隐藏使用this作为同步监视器(锁)
2.同步方法解决实现继承Thread的线程创建方式的线程安全问题
@Override
public void run() {
while(true) {
show();
}
}
private static synchronized void show() {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName() + "售票，票号为:" + tickets);
tickets--;
}
}
此时同步监视器为当前的类
1.2.2 线程同步解决单例模式懒汉式的线程安全问题
方式一：效率稍差
public class Bank {
private static Bank bank = null;
private Bank() {
}
public static Bank getBank() {
synchronized (Bank.class) {
if (bank == null)
bank = new Bank();
return bank;
}
}
}
方式二:效率更高
public class Bank {
private static Bank bank = null;
private Bank() {
}
public static Bank getBank() {
if(bank == null) {
synchronized (Bank.class) {
if (bank == null)
bank = new Bank();
}
}
return bank;
}
}
1.3 线程的死锁问题 DeadLock
不同线程分别占用对方需要同步的资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。出现死锁，不会出现异常，不会出现提示，只是所有的线程都处于堵塞状态，无法继续。
public class theadsTest {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread() {
@Override
public void run() {
synchronized (s1) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
s1.append("a");
s2.append("1");
synchronized (s2) {
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2) {
s1.append("c");
s2.append("3");
synchronized (s1) {
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
解决方法
专门的算法、原则
尽量减少共享资源的使用
尽量避免嵌套同步
1.4 Lock锁解决线程安全问题 jdk5.0新增
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock();
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售票，票号为:" + ticket);
ticket--;
} else {
break;
}
}finally {
lock.unlock();
}
}
}
lock方法默认this为同步监视器，因此线程创建方式只能使用实现Runnable接口的方式，继承的方式需要加static。synchronized在执行完同步代码后会手动释放同步监视器，lock方式需要手动启动同步(lock())，同时结束同步也需要
优先使用顺序:Lock->同步代码块(已经进入方法体，分配了相应资源)->同步方法(在方法体之外)
1.4 线程的通信
@Override
public void run() {
while(true) {
synchronized (this) {
notify();
if (num <= 100) {
System.out.println(Thread.currentThread().getName() + ":" + num);
num++;
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
else {
break;
}
}
}
}
线程一首先获得同步监视器（锁），执行输出后wait()进入了阻塞状态，释放了手中的锁，随后线程二执行notify()唤醒线程一，线程二获得锁进入执行输出（线程一此时没有锁不能够执行），随后线程二wait()进入堵塞状态释放手中的锁，进程一获得锁后执行notify唤醒线程二......以此实现交叉输出。
| 线程通信方法 | 说明 |
|---|---|
| wait() | 当前线程进入堵塞状态并释放同步监视器 |
| notify() | 唤醒一个wait的线程，若多个线程处于堵塞状态则唤醒优先级高的哪一个。 |
| notifyAll() | 唤醒所有的线程。 |
三个方法必须使用在同步代码块或者同步方法中，且三个方法的调用者必须是同步代码块或者同步方法的同步检测器，因此synchronized (this)参数不能为类或者obj。否则会出现IllegalMonitorStateException，或者写为obj.wait()。此外三个方法定义在java,lang.object中。
面试题 sleep() 和 wait()方法的异同
相同点：都能够使线程堵塞。
不同点：①Thread中定义的sleep，Object中定义的wait。
②wait只能使用在同步代码块和同步方法中，由同步检测器调用。
③wait会释放线程的同步检测器，sleep则不会。
生产者消费者问题
package com.hikaru.exer;
class Clerk {
private static int num = 0;
public synchronized void product() {
if(num < 20) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
num++;
System.out.println(Thread.currentThread().getName() + "正在生产第" + num + "产品...");
notify();
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void consume() {
if(num > 0) {
// try {
// Thread.sleep(500);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(Thread.currentThread().getName() + "正在消费第" + num + "产品...");
num--;
notify();
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Producer extends Thread{
private Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(this.getName() + "开始生产产品...");
while(true) {
clerk.product();
}
}
}
class Customer extends Thread{
private Clerk clerk;
public Customer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(this.getName() + "开始消费产品...");
while(true) {
clerk.consume();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
Customer c1 = new Customer(clerk);
p1.setName("生产者一");
c1.setName("消费者一");
c1.start();
p1.start();
}
}
1.5 通过实现Callable接口新增线程 jdk5.0新增
优点：①call方法相比run()方法，可以有返回值
②方法可以抛出异常
③支持泛型的返回值
④需要借助FutureTask类，比如获取返回结果
FutureTask
FutureTask是Future的唯一实现类，可以对Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。FutureTask同时实现了Runnable、Callable接口，它既可作为Runnable被线程执行，又可作为Future得到Callable的结果。
NumThread numThread = new NumThread();//创建Callable接口实现类
FutureTask futureTask = new FutureTask(numThread);
Thread t1 = new Thread(futureTask);//作为Runnable被线程执行
t1.start();
try {
System.out.println(futureTask.get());//作为Future得到Callable的结果
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
1.6 使用线程池创建线程
经常创建和销毁线程、使用量特别大的资源，比如并发情况下的线程，对性能的影响很大。提前创建好多个线程放入线程池中，使用时直接获取，用完放回线程池。能够提高响应速度，降低资源消耗，便于资源管理。
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(10);
service.execute(new NumThread());//适用于Runnable
// service.submit();//适用于Callable
service.shutdown();
}
ExecutorServic
真正的连接池接口。常见子类ThreadPoolExecutor
| execute(Runnable command) | 执行命令，没有返回值，一般用来执行Runnable |
| submit(Callable task) | 执行命令，有返回值，一般用来执行Callable |
| shutdown | 关闭连接池 |
Executors
工具类、线程池的工厂类，用于创建返回不同类型的线程池
