多线程
多线程的创建
创建方式1:继承Thread类
public class MainTest {
public static void main(String[] args) {
//创建线程对象
MyThread myThread=new MyThread();
//启动线程
myThread.start();
for (int i = 1; i <=5 ; i++) {
System.out.println("主线程:"+i);
}
}
}
public class MyThread extends Thread{
@Override
public void run() {
//这里定义子线程完成的任务
for (int i = 1; i <= 5; i++) {
System.out.println("子线程MyThread:"+i);
}
}
}
创建方式2:实现Runnable接口
public class MainTest {
public static void main(String[] args) {
MyRunnable myRunnable=new MyRunnable();
new Thread(myRunnable).start();
for (int i = 1; i <=5 ; i++) {
System.out.println("主线程:"+i);
}
}
}
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 1; i <=5 ; i++) {
System.out.println("子线程:"+i);
}
}
}
//子线程1
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <=5 ; i++) {
System.out.println("子线程1:"+i);
}
}
}).start();
//子线程2,Lambda表达式
new Thread(() ->{
for (int i = 1; i <=5 ; i++) {
System.out.println("子线程2:"+i);
}
}).start();
//子线程3
Runnable tartget=new Runnable() {
@Override
public void run() {
for (int i = 1; i <=5 ; i++) {
System.out.println("子线程3:"+i);
}
}
};
new Thread(tartget).start();
for (int i = 1; i <=5 ; i++) {
System.out.println("主线程:"+i);
}
创建方式3:实现Callable接口
public class MainTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//1、创建实现了Callable接口类的对象
Callable<String> callable=new MyCallable(100);
//2、把Callable的对象封装成一盒FutureTask对象(任务对象)
//未来任务对象的作用?
//1、是一个任务对象,实现列Runnable接口
//2、可以在线程执行完毕后,用未来对象调用get方法获取线程执行完毕的返回值
FutureTask<String> f1=new FutureTask<>(callable);
//3、把任务对象交给一个Thread对象
new Thread(f1).start();
//4、获取线程执行完毕后返回的结果
//注意:如果执行到这,假如上面的线程还没有执行完毕
//这里的代码会暂停,等待上面线程执行完毕后才会获取结果
//同时这里也要处理相应的异常
String s = f1.get();
System.out.println(s);
}
}
public class MyCallable implements Callable<String> {
private int n;
public MyCallable(int n) {
this.n = n;
}
@Override
public String call() throws Exception {
//描述此线程完成的任务
int sum=0;
for (int i = 1; i <=n ; i++) {
sum+=i;
}
return "从1加到"+n+"的结果是:"+sum;
}
}
线程常用方法
public class MyThread extends Thread{
public MyThread(String name){
super(name); //1.执行父类Thread(String name)构造器,为当前线程设置名字了
}
@Override
public void run() {
//2.currentThread() 哪个线程执行它,它就会得到哪个线程对象。
Thread t = Thread.currentThread();
for (int i = 1; i <= 3; i++) {
//3.getName() 获取线程名称
System.out.println(t.getName() + "输出:" + i);
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
Thread t1 = new MyThread();
t1.setName(String name) //设置线程名称;
t1.start();
System.out.println(t1.getName()); //Thread-0
Thread t2 = new MyThread("2号线程");
// t2.setName("2号线程");
t2.start();
System.out.println(t2.getName()); // Thread-1
// 主线程对象的名字
// 哪个线程执行它,它就会得到哪个线程对象。
Thread m = Thread.currentThread();
m.setName("最牛的线程");
System.out.println(m.getName()); // main
for (int i = 1; i <= 5; i++) {
System.out.println(m.getName() + "线程输出:" + i);
}
}
}
join方法调用:
public class ThreadTest2 {
public static void main(String[] args) throws Exception {
// join方法作用:让当前调用这个方法的线程先执行完。
Thread t1 = new MyThread("1号线程");
t1.start();
t1.join();
Thread t2 = new MyThread("2号线程");
t2.start();
t2.join();
Thread t3 = new MyThread("3号线程");
t3.start();
t3.join();
}
执行效果是1号线程先执行完,再执行2号线程;2号线程执行完,再执行3号线程;3号线程执行完就结束了。
线程安全问题
线程同步:解决线程安全问题
同步思想概述
小红获得锁,操作完成后会释放锁
方式一:同步代码块
同步代码块的作用就是把访问共享数据的代码锁起来,以此保证线程安全。
//锁对象:必须是一个唯一的对象(同一个地址)
synchronized(锁对象){
//...访问共享数据的代码...
}
使用同步代码块,来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可。
// 小明 小红线程同时过来的
public void drawMoney(double money) {
// 先搞清楚是谁来取钱?
String name = Thread.currentThread().getName();
// 1、判断余额是否足够
// this正好代表共享资源!
synchronized (this) {
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功!");
this.money -= money;
System.out.println(name + "来取钱后,余额剩余:" + this.money);
}else {
System.out.println(name + "来取钱:余额不足~");
}
}
}
此时再运行测试类,观察是否会出现不合理的情况。
最后,针对锁对象如何选择:
1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法,建议使用this作为锁对象
3.对于静态方法,建议把类的字节码(类名.class)当做锁对象
方式二:同步方法
方式三:Lock锁
1.首先在成员变量位子,需要创建一个Lock接口的实现类对象(这个对象就是锁对象)
private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
lk.lock(); // 加锁
//...中间是被锁住的代码...
lk.unlock(); // 解锁
// 创建了一个锁对象
private final Lock lk = new ReentrantLock();
public void drawMoney(double money) {
// 先搞清楚是谁来取钱?
String name = Thread.currentThread().getName();
try {
lk.lock(); // 加锁
// 1、判断余额是否足够
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功!");
this.money -= money;
System.out.println(name + "来取钱后,余额剩余:" + this.money);
}else {
System.out.println(name + "来取钱:余额不足~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lk.unlock(); // 解锁
}
}
}
线程通信(了解)
首先,什么是线程通信呢?
- 当多个线程共同操作共享资源时,线程间通过某种方式互相告知自己的状态,以相互协调,避免无效的资源挣抢。
线程通信的常见模式:是生产者与消费者模型
- 生产者线程负责生成数据
- 消费者线程负责消费生产者生成的数据
- 注意:生产者生产完数据后应该让自己等待,通知其他消费者消费;消费者消费完数据之后应该让自己等待,同时通知生产者生成。
比如下面案例中,有3个厨师(生产者线程),两个顾客(消费者线程)。
接下来,我们先分析一下完成这个案例的思路
1.先确定在这个案例中,什么是共享数据?
答:这里案例中桌子是共享数据,因为厨师和顾客都需要对桌子上的包子进行操作。
2.再确定有那几条线程?哪个是生产者,哪个是消费者?
答:厨师是生产者线程,3条生产者线程;
顾客是消费者线程,2条消费者线程
3.什么时候将哪一个线程设置为什么状态
生产者线程(厨师)放包子:
1)先判断是否有包子
2)没有包子时,厨师开始做包子, 做完之后把别人唤醒,然后让自己等待
3)有包子时,不做包子了,直接唤醒别人、然后让自己等待
消费者线程(顾客)吃包子:
1)先判断是否有包子
2)有包子时,顾客开始吃包子, 吃完之后把别人唤醒,然后让自己等待
3)没有包子时,不吃包子了,直接唤醒别人、然后让自己等待
按照上面分析的思路写代码。
桌子类:
public class Desk {
private List<String> list=new ArrayList<>();
/**
* 同步方法,所得对象是this
* 厨师1、厨师2、厨师3
*/
public synchronized void put() {
try {
if (list.isEmpty()){
String name = Thread.currentThread().getName();
list.add(name+"做的包子!");
System.out.println(name+"做了包子!");
Thread.sleep(2000);
//唤醒其他线程,该线程等待
this.notifyAll();
this.wait();
}else
{
//唤醒其他线程,该线程等待
this.notifyAll();
this.wait();
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 吃货1、吃货2
* 这两个同步方法的锁是同一个即this
*/
public synchronized void get() {
try {
if (!list.isEmpty()){
String name = Thread.currentThread().getName();
System.out.println(name+"吃了"+list.get(0));
Thread.sleep(1000);
//清空集合
list.clear();
//唤醒其他线程,该线程等待
this.notifyAll();
this.wait();
}else {
//唤醒其他线程,该线程等待
this.notifyAll();
this.wait();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
测试类:
public class MainTest {
public static void main(String[] args) {
//创建桌子对象
Desk desk=new Desk();
//创建3个厨师线程
new Thread(() ->{
while (true){
desk.put();
}
},"厨师1").start();
new Thread(() ->{
while (true){
desk.put();
}
},"厨师2").start();
new Thread(() ->{
while (true){
desk.put();
}
},"厨师3").start();
new Thread(() ->{
while (true){
desk.get();
}
},"吃货1").start();
new Thread(() ->{
while (true){
desk.get();
}
},"吃货2").start();
}
}
线程池(重要)
认识线程池
而使用线程池,就可以解决上面的问题。如下图所示,线程池内部会有一个容器,存储几个核心线程,假设有3个核心线程,这3个核心线程可以处理3个任务。
但是任务总有被执行完的时候,假设第1个线程的任务执行完了,那么第1个线程就空闲下来了,有新的任务时,空闲下来的第1个线程可以去执行其他任务。依此内推,这3个线程可以不断的复用,也可以执行很多个任务。
所以,线程池就是一个线程复用技术,它可以提高线程的利用率。
创建线程池
面试时可能会问
注意:核心线程数的选择
需要根据具体需求具体分析,以下是一些经验(只做参考):
1、计算密集型(基本上都是运算)的任务:核心线程数=CPU的核数+1
2、IO密集型(涉及读写文件)的任务:核心线程数=CPU的核数*2
线程池执行Runnable任务
public class MainTest {
public static void main(String[] args) {
//创建线程池对象
ExecutorService pool=new ThreadPoolExecutor(
3, 5, 8, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory()
, new ThreadPoolExecutor.AbortPolicy());
Runnable runnable=new MyRunnable();
//执行Runnable任务
pool.execute(runnable);//线程池会自动创建一个新线程,自动执行任务
pool.execute(runnable);//线程池会自动创建一个新线程,自动执行任务
pool.execute(runnable);//线程池会自动创建一个新线程,自动执行任务
pool.execute(runnable);//复用核心线程池
pool.execute(runnable);//复用核心线程池
pool.execute(runnable);//复用核心线程池
pool.execute(runnable);//复用核心线程池,此时,任务队列满了
// pool.execute(runnable);//当核心线程都被占用且任务队列满了,此时若还能创建临时线程则创建临时线程
// pool.execute(runnable);//创建临时线程
//到了拒绝新任务的时候
pool.execute(runnable);
// pool.shutdown();//执行完线程任务关闭线程池
pool.shutdownNow();//立即关闭线程池,停止正在执行的任务,并返回队列中未执行的任务
}
}
public class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程池执行Callable任务
public class MyCallable implements Callable<String> {
private int n;
public MyCallable(int n) {
this.n = n;
}
// 2、重写call方法
@Override
public String call() throws Exception {
// 描述线程的任务,返回线程执行返回后的结果。
// 需求:求1-n的和返回。
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return Thread.currentThread().getName() + "求出了1-" + n + "的和是:" + sum;
}
}
public class ThreadPoolTest2 {
public static void main(String[] args) throws Exception {
// 1、通过ThreadPoolExecutor创建一个线程池对象。
ExecutorService pool = new ThreadPoolExecutor(
3,
5,
8,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(4),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
// 2、使用线程处理Callable任务。
Future<String> f1 = pool.submit(new MyCallable(100));
Future<String> f2 = pool.submit(new MyCallable(200));
Future<String> f3 = pool.submit(new MyCallable(300));
Future<String> f4 = pool.submit(new MyCallable(400));
// 3、执行完Callable任务后,需要获取返回结果。
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
}
}
执行后,结果如下图所示
Executors工具类实现线程池
补充:并行、并发、生命周期(重要)
多线程到底是怎么在执行的?
并发和并行同时进行!!!
线程的生命周期
补充:悲观锁与乐观锁
悲观锁:一上来就加锁,每一个线程都是要排队,没有安全感,每次只能一个线程进入访问完毕后,再解锁。线程安全,但性能较差!
乐观锁:一开始不上锁,认为是没有问题,大家一起跑,等要出现线程安全问题的时候才开始控制。线程安全,性能好!
乐观锁涉及到CAS算法(比较修改算法),其中对一些数的操作已经封装成了原子类,如Int类型的原子类是AtomicInteger,内部就是实现了乐观锁。