多线程详解
Posted 好好学java的xz
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了多线程详解相关的知识,希望对你有一定的参考价值。
4.4 题外话
根据多线程详解(一)的同步,
我们可以使用同步机制将单例模式中的懒汉式改写为线程安全的。
举例:
public class BankTest
class Bank
private Bank()
private static Bank instance = null;
public static Bank getInstance()
//方式一:在方法上 加 synchronized 效率稍差
//方式二:效率稍差 只要判断一次同步一次 后面就不用同步了
//解决方案就相当于只有一台手机 买完人走了 出公告 手机卖完了 不用再进来了
// synchronized (Bank.class)
// if (instance == null)
// instance = new Bank();
//
// return instance;
//
//方式三:效率更高
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是锁
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;
//1.实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
//默认值是false 参数是boolean fair(公平)
// 设置true 先进先出 一个个执行 不会出现有个执行了下一刻又抢到了
@Override
public void run()
while (true)
try
//2.调用锁定方法lock()
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
//3.调用解锁方法:unlock()
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) //this代表number对象
notify();//线程一把线程二唤醒 线程二把线程一唤醒 notifyAll()就是唤醒所有 省略了this
if (number <= 100)
try
Thread.sleep(10);//sleep 不会释放锁
catch (InterruptedException e)
e.printStackTrace();
System.out.println(Thread.currentThread().getName() + ":" + number);
number++;
//使得调用如下wait() 方法的线程进入阻塞状态 wait会释放锁
try
wait();// 省略了this
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;
//1.创建一个实现Callable的实现类
class NumThread implements Callable<Integer>
//2.实现call方法,将此线程需要执行的操作声明在call()中
@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)
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask 的对象
FutureTask<Integer> futureTask = new FutureTask<>(numThread);
//5.将Future Task的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
new Thread(futureTask).start();
try
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的calL()的返回值。
Integer sum = futureTask.get();//调get方法获取Callable接口实现类的回调方法
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)
//1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);//造了个线程池
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());//获取是哪个类造的
service1.setCorePoolSize(15);
//2.执行指定的线程的操作。需要提供实现Runnable接口 或 Callable接口实现类的对象
//线程要干什么不知道 所以还是要提供实现 Runnable接口的 实现类
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合适用于Callable
service.shutdown();//3.关闭线程池
9. 面试题
一共有几种多线程创建方式? 》 4种
解决线程安全问题? 》3种
以上是关于多线程详解的主要内容,如果未能解决你的问题,请参考以下文章