4.4 题外话
根据多线程详解（一）的同步，
我们可以使用同步机制将单例模式中的懒汉式改写为线程安全的。
举例：
public class BankTest { }
class Bank{
private Bank(){}
private static Bank instance = null;
public static Bank getInstance() {
if (instance == null){
synchronized (Bank.class) {
if (instance == null){
instance = new Bank();
}
}
}
return instance;
}
}
5 线程的死锁问题
5.1 概念
5.1.1 死锁的理解
不同的线程分别占用对方需要的同步资源不放弃，
都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
5.1.2 说明
1.出现死锁后，不会出现异常，不会出现提示，
只是所有的线程都处于阻塞状态，无法继续
2.我们使用同步时，要避免出现死锁
5.1.3举例
一人一个筷子，互不相让，就打起来了。
5.2 解决方法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
5.3 演示线程的死锁问题
public class ThreadTest {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run() {
synchronized (s1){
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
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");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
一个等着拿s2 一个拿着s2等着拿s1 互相僵持
6.JDK5.0 新增解决线程安全问题
6.1 概念
解决线程安全问题的方式三： Lock锁 —JDK5.0新增
》通过显式定义同步锁对象来实现同步。
》同步锁使用Lock对象充当。
6.2 步骤
- 实例化ReentrantLock
- 调用锁定方法lock()
- 调用解锁方法：unlock()
6.3 举例
使用Lock锁解决实现Runnable接口的线程安全问题
import java.util.concurrent.locks.ReentrantLock;
class Window implements Runnable{
private int ticket = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock();
if (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
ticket --;
}else {
break;
}
}finally {
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
如果你用的是继承于Thread类 lock要加个静态 要用同一个
6.4 synchronized与Lock 的异同?（面试题）
相同:
二者都可以解决线程安全问题
不同:
synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器。
Lock需要手动的启动同步(Lock()) ，同时结束同步也需要手动的实现(unLock())。
优先使用顺序:
Lock >同步代码块(已经进入了方法体，分配了相应资源)>同步方法(在方法体之外)
7.线程的通信
7.1 线程通信的例子
使用两个线程打印1-100。线程1,线程2交替打印(一个一个交互进入)
7.2 涉及到三个方法及注意点
7.2.1 方法
wait():
一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():
一旦执行此方法，就会唤醒被wait的一个线程。
如果有多个线程被wait,就唤醒优先级高的那个。
notifyAll():
一旦执行此方法,就会唤醒所有被wait的线程
7.2.2 注意点：
1.wait(), notify(), notifyAll() 三个方法必须使用在同步代码块或同步方法中。
2.wait(), notify(), notifyAll() 三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
否则，会出现IllegaLMonitorStateException异常
3.wait(), notify(), notifyAll() 三个方法是定义在java.lang.Object类中。
7.2.3 面试题： sleep() 和 wait() 的异同？
相同点：
一旦执行方法， 都可以使得当前的线程进入阻塞状态。
不同点：
1）两个方法声明的位置不同: Thread类中声明sleep()，object类中声明wait()
2）调用的要求不同:
sleep()可以在任何需要的场景下调用。
wait()必须使用在同步代码块或同步方法中
3）关于是否释放同步监视器：
如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait() 会释放锁。
7.3 举例
class Number implements Runnable {
private int number = 1;
@Override
public void run() {
while (true){
synchronized (this) {
notify();
if (number <= 100) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + number);
number++;
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
8.JDK5.0新增线程创建方式
8.1 多线程创建，方式三:实现Callable接口
8.1.1 步骤
Future接口最重要
- 创建一个实现Callable的实现类
- 实现call方法，将此线程需要执行的操作声明在call()中
- 创建Callable接口实现类的对象
- 将此Callable接口实现类的对象作为传递到FutureTask构造器中，
创建FutureTask 的对象 - 将Future Task的对象作为参数传递到Thread类的构造器中，
创建Thread对象，并调用start() - 获取Callable中call方法的返回值
8.1.2 Callable比Runnable更强大
如何理解实现Callable接口的方式创建多线程
比实现Runnable接口创建多线程方式要强大
- call()可以有返回值的
- call() 可以抛出异常，被外面的操作捕获，获取异常的信息
- Callable是支持泛型的
8.1.3 举例
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class NumThread implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1 ; i <= 100 ; i++) {
if (i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
NumThread numThread = new NumThread();
FutureTask<Integer> futureTask = new FutureTask<>(numThread);
new Thread(futureTask).start();
try {
Integer sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
8.2 多线程创建，方式四：使用线程池（开发常用的）
8.2.1 介绍
背景：
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
解决方案:
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
8.2.2 步骤
- 提供指定线程数量的线程池
- 执行指定的线程的操作。
需要提供实现Runnable接口 或 Callable接口实现类的对象 - 关闭线程池
8.2.3 好处
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程，不需要每次都创建)
- 便于线程管理
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止
8.2.4 举例
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
class NumberThread implements Runnable {
@Override
public void run() {
for (int i = 1 ; i <= 100 ; i++) {
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
class NumberThread1 implements Runnable {
@Override
public void run() {
for (int i = 1 ; i <= 100 ; i++) {
if (i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
service1.setCorePoolSize(15);
service.execute(new NumberThread());
service.execute(new NumberThread1());
service.shutdown();
}
}
9. 面试题
一共有几种多线程创建方式？ 》 4种
解决线程安全问题？ 》3种
|