Java基础知识 — 多线程
-
多线程的概念
线程是指一个任务从头到尾的执行流,线程提供了一个运行的机制。
在Java
中,一个程序中可以并发的启动多个线程,这也就意味着线程可以在多处理器系统上同一时刻运行。
多线程可以使程序反应更快,执行效率更高。
- 多线程编程
以上介绍的概念可能还不够清晰的解释什么是多线程,没关系,我们举一个例子看一下。当然,如果我们想要创建一个多线程程序,那么首先我们应该提供多个任务供我们去执行,想要创建一个这样的任务,我们需要实现 Runnable
接口,打开Runnable
源码如下
public interface Runnable { public abstract void run(); }
很简单,其中只是包含了一个 run()
的抽象方法,只要我们在子类中去实现它就可以了。
创建一个打印 “ I am task a!” 的任务
public class A implements Runnable{ @Override public void run() { System.out.println("I am task a !"); } }
基于同样的原理,实现一个打印 “ I am task b !” 和一个 “I am task c !”的方法,代码同上。然后在主函数中去开启线程,实现打印任务。
主函数实现如下:
public class Main { public static void main(String[] args){ int i = 0; while(50 >= i){ Thread threadA = new Thread(new A()); Thread threadB = new Thread(new B()); Thread threadC = new Thread(new C()); threadA.start(); threadB.start(); threadC.start(); i++; } } }
在主函数中我们开启了这三个线程,去实现打印任务,按照我们平常的理解,该程序肯定是依次执行A,B,C任务,但是打印结果却是:
I am task b ! I am task c ! I am task a ! I am task c ! I am task a ! I am task b ! I am task b ! I am task a ! I am task c ! I am task b !
怎么样,看到这里,你应该知道什么是多线程了,但是你肯定又有一个疑问,难道我们每次开线程都要去new Thread()
吗?
当然不是,这种方法对于执行单个任务而言确实很方便,但是当我们大量的任务时,这种方法显然是十分繁琐的,而且会降低性能,所以我们要引出另一个概念,也就是线程池。
3 . 线程池
Java
提供了Executor
接口来执行线程池中的任务,提供ExecutorServive
接口来管理和控制任务。下面我们来看看Executor
和 ExecutorService
这两个接口。
public interface Executor { void execute(Runnable command); }
可见,Executor
接口只是提供了一个 execute()
方法,通过其函数,我们应该可以得出这个方法是我们执行任务时使用的一个函数,类似于 Thread
类中的start()
方法。
public interface ExecutorService extends Executor { void shutdown(); //关闭执行器,但是允许完成当前任务。一旦关闭,无法再接收新的任务 List<Runnable> shutdownNow(); //强制关闭执行器,就算当前线程池中存在尚未完成的任务,仍然立即关闭 boolean isShutdown();//如果执行器已经关闭,则返回 true boolean isTerminated(); //如果线程池中的任务都被终止,则返回true }
当然,ExecutorService
中还包含其他方法,以上列出的只是几个常用的方法,可以看到,ExecutorService
是继承Executor
接口的,但是这些都只是接口,并没有提供具体的实现方法,我们该如何利用线程池开启我们的任务呢?当然,还存在一个 Executors
类,这个类中实现了创建线程池的方法,主要有两种方式
//创建一个线程池,该线程池可并发执行的线程数固定不变。 + newFixedThreadPool(numberOfThreads : int) : ExecutorService //创建一个线程池,可以按需要创建新线程,也即线程数可变 + newCachedThreadPool():ExecutorService
下面我就用线程池的方法,实现A,B,C任务。
public class Main { public static void main(String[] args){ int i = 0; ExecutorService executor = Executors.newFixedThreadPool(3); while(10 > i){ executor.execute(new A()); executor.execute(new B()); executor.execute(new C()); executor.shutdown(); i++; } } }
学过计算机组成原理的人可能知道指令流水线设计,影响流水线性能的有三大原因,其中有一点就是数据相关,也就是由于重叠操作,改变了对操作数读写的访问顺序,从而导致了数据相关冲突。在多线程里面,会不会发生这种情况呢? 答案是肯定的,下面我们来举一个例子:
设计一个IPhoneShop 类
public class IPhoneShop { private static int number = 3; public static void sellIPhone(){ if(0 < number){ try { Thread.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); } number --; System.out.println("Sell a IPhone !"); } else { System.out.println("Sell out !"); } } }
类的设计十分简单,初始化店内只有3台IPhone,如果卖出去一部,就打印卖出一部IPhone,如IPhone数量为0,则打印已经卖完了,在sellIPhone()
方法中,我设置了线程睡眠 5 毫秒,是为了增大差异,更明显的看出线程的竞争状态。
这时的主函数为
public class Main { public static IPhoneShop mShop = new IPhoneShop(); public static void main(String[] args){ int i = 1; ExecutorService executor = Executors.newFixedThreadPool(100); while(100 >= i){ executor.execute(new A()); i++; } executor.shutdown(); } }
A类
public class A implements Runnable{ @Override public void run() { Main.mShop.sellIPhone(); } }
执行之后你会发现有意思的事情
I got a IPhone ! I got a IPhone ! Sell out ! I got a IPhone ! I got a IPhone ! I got a IPhone ! I got a IPhone ! I got a IPhone ! Sell out ! Sell out ! Sell out ! I got a IPhone ! I got a IPhone ! I got a IPhone ! I got a IPhone ! I got a IPhone !
这里只是粘贴了部分结果,显然,已经超出了IPhone的数量,这时为什么呢?当一个线程通过 sellIPhone()
的 if 判断时,我们设置了线程睡眠,这个时候,IPhone的数量并没有减少,而另一个线程又进来了,这个时候 if 判断也就失去了其意义,因为在number数量还未来得及减少的时候,很多子线程已经通过了if判断。
为了解决这个问题,Java
引入了synchronized
关键字,这个关键字用于同步线程,以便一次只有一个线程能够访问这个方法。也就是说,当一个线程进入这个方法后,这个方法便被加了锁,别的线程只能够选择等待,直到前一个进入的线程执行完为止,这样就解决了线程间的竞争问题。
public static synchronized void sellIPhone()
只需要这样更改,便不会出现以上问题了,这也是synchronized
关键字的简单用法。但是synchronized
是隐式加锁,具体实现我们并看不到,那么有没有一种方法,能够显式给方法加锁呢?
4.使用 Lock 加锁同步
首先来介绍一下Lock
接口,看看定义
public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); Condition newCondition() }
我们主要能够用到lock()
, unlock()
, newCondition()
三个方法,顾名思义,lock()
用于加锁,unlock()
用于解锁, newCondition()
返回绑定到Lock
实例的新的Condition
实例。下面就让我们使用Lock
方法来进行方法的显式加锁。
public class IPhoneShop { private static int number = 3; private static Lock mLock = new ReentrantLock(); public static void sellIPhone(){ mLock.lock(); if(0 < number){ try { Thread.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); } number --; System.out.println("I got a IPhone !"); } else { System.out.println("Sell out !"); } mLock.unlock(); } }
这样也就实现了和synchronized
一样的效果,这样也显得更加灵活和直观。
想象一下刚才卖IPhone 的场景,如果在卖的同时,又进了新货,可不可以让那么没有没到IPhone的用户先等待一下,等到进新货时,由店家通知所有没有买到IPhone的用户,我们又进了新货,你们可以来买了。
这就涉及到了线程间的协作问题,还记得Lock 接口中的那个 newCondition()
方法吗?Condition
接口中存在三个重要的方法,也就是await()
,signal()
, signalAll()
方法。await()
方法可以让当前线程都处于等待状态,signal() 方法可以唤醒一个等待的线程,signalAll()
方法可以唤醒所有的等待线程.
public class IPhoneShop { private static int number = 3; private static Lock mLock = new ReentrantLock(); private static Condition newCondition = mLock.newCondition(); public static void sellIPhone(){ mLock.lock(); if(0 < number){ number --; System.out.println("I got a IPhone !"); } else { System.out.println("Sell out !"); try { newCondition.await(); } catch (InterruptedException e) { e.printStackTrace(); } } mLock.unlock(); } public static void getIPhone(){ mLock.lock(); number += 3; newCondition.signalAll(); mLock.unlock(); } }
这样,当IPhone售完后,所有线程将进入等待阶段,直到再次进货,newCondition
唤醒所有的等待线程,再次进入销售环节。这样就实现了使用Condition
线程间的协作。
5.信号量
信号量可以用于限制访问共享资源的线程数,在访问资源前,必须获得信号的许可,所以,使用这种方法,也可以达到给方法加锁的目的,其效果和synchronized
关键字和Lock
是类似的。
使用信号量的方法为
Semaphore mSemaphore = new Semaphore(numberOfPermits:int); 或者 Semaphore mSemaphore = new Semaphore(Permits:int,fairs:boolean);//可以创建一种具有公平策略的信号量,所谓公平策略也就是说等待时间最长的线程获得方法的使用权
Semaphore
类中有两个重要方法,acquire()
和 release()
两个方法,第一个方法表示这个线程已经获得了方法的使用权,如果获得使用权的线程数等于指定的数,那么其他线程将不能再获得方法的使用权。release()
用于线程释放使用权。
具体使用如下
Semaphore mSemaphore = new Semaphore(2); public void method(){ try { mSemaphore.acquire(); } catch (InterruptedException e) { e.printStackTrace(); } finally{ mSemaphore.release(); } }
原文地址:https://www.jianshu.com/p/6acf0f74dad5
相关推荐
-
Java 8 创建 Stream 的 10 种方式,我保证你受益无穷! Java基础
2019-7-20
-
Redis的正确使用姿势 Java基础
2019-5-17
-
文件上传JQuery插件 ajaxFileUpload 不严谨的bug Java基础
2020-5-29
-
银行交易系统 TiDB 在线缩容迁移 转 Java基础
2019-7-4
-
【杂谈】从CGI到Servlet Java基础
2019-7-28
-
Java HTTP 组件库选型看这篇就够了 Java基础
2018-10-31
-
当观察者模式遇到线程 Java基础
2019-8-20
-
高并发请求的缓存设计策略 Java基础
2018-10-22
-
通过nginx反向代理来调试代码 Java基础
2020-6-15
-
RabbitMQ 延迟队列,消息延迟推送 Java基础
2019-9-15