1. 线程简介
程序:静态概念,是指令和数据的有序集合。
进程:动态概念,执行程序的一次执行过程,是系统资源分配的单位。
线程:独立的执行路径,每一个线程都有自己的局部变量表、程序计数器(指向正在执行的指令指针)以及各自的生命周期。
- 一个进程Process至少有一个线程Thread,线程是CPU调度和执行的单位。
- 线程运行由调度器安排调度,调度器与操作系统紧密相关,先后顺序不能人为干预。
- 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程、gc线程。
- main()称之为主线程,为系统的入口,用于执行整个程序。
- 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制。
- 线程会带来额外的开销,如CPU调度时间,并发控制开销。
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致。
- 线程启动必须在其中一个任务之前,否则线程将永远得不到启动,因为前一个任务永远不会结束。
- 借助Jconsole或者Jstack命令查看线程。
注意:很多多线程是模拟出来的,即在同一CPU下,同一个时间点只执行一个代码,因为切换很快,所以有同时执行的错觉。真正的多线程是指有多个CPU,即多核,如服务器。
2. 线程实现
2.1 线程创建
方法一:继承Thread类
(实现了Runnable接口)
每个线程都有优先权(但最终仍由CPU决定)。每个线程可能也可能不会被标记为守护程序。当在某个线程中运行的代码创建一个新的Thread对象时,新线程的优先级最初设置为等于创建线程的优先级,并且当且仅当创建线程是守护进程时才是守护线程。
不建议使用:避免OOP单继承局限性
实现:将一个类声明为Thread的子类,该子类重写run类的方法Thread,然后分配并启动子类的实例。
public class TestThread extends Thread{
@override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码");
}
}
public static void main(String[] args) {
TestThread testThread = new TestThread();
testThread.start(); // 同时交替进行
// 线程开启不一定立即执行,由CPU调度
testThread.run(); // 先调用run方法(错误)
for (int i = 0; i < 20; i++) {
System.out.println("多线程");
}
}
}
案例:多线程下载图片
下载commons-io.jar包
public class TestThread extends Thread{
private String url;
private String name;
public TestThread(String url,String name){
this.url = url;
this.name = name;
}
@override
public void run(){
WebDownLoader webDownloder = new WebDownLoader();
webDownloder.downloder(url,name);
}
public static void main(String[] args){
TestThread t1 = new TestThread("https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3403164926,2805624001&fm=26&gp=0.jpg","1.jpg");
t1.start();
}
}
class WebDownLoader{
public woid downloder(String url,String name){
try{
FileUtils.copyURLToFile(new URL(url), new File(name));
}catch(IOException e){
e.printStackTrace();
System.out.println("IO异常");
}
}
}
方法二:实现Runnable接口
声明实现类Runnable接口,该类重写run方法,通过分配类的实例,在创建Thread时作为参数传递并启动。
启动线程:传入目标对象+Thread对象.start()
推荐使用:避免单继承局限性,灵活方便,方便同一个对象被多个线程使用
public class TestThread implements Runnable{
@override
public void run(){
for (int i = 0; i < 20; i++){
System.out.println("代码");
}
}
public static void main(String[] args){
TestThread testThread = new TestThread();
Thread thread = new Thread(testThread);
thread.start();
//new Thread(testThread).start();
for (int i = 0; i < 20; i++) {
System.out.println("多线程");
}
}
}
案例:买火车票
public class TestThread implements Runnable(){
private int ticketNums = 10;
@override
public void run(){
while (true) {
if (ticketNums <= 0){
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getNames()+"拿到了第"+ticketNames--+"票");
}
}
public static void main(String[] args) {
TestThread ticket= new TestThread();
new Thread(ticket,"小明").start();
new Thread(ticket,"老师").start();
new Thread(ticket,"黄牛党").start();
}
}
案例:龟兔赛跑
public class Race implements Runnable {
private static String winner;
@override
public void run() {
for (int i = 0; i <= 100; i++) {
//模拟兔子休息
if (Thread.currentThread().getName().equals("兔子") && i%10==0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean glag = gameOver(i);
if (flag){
break;
}
System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步";
}
}
private boolean gameOver() {
if (winner != null) {
return true;
}{
if (steps >= 100){
winner = Thread.currentThread().getName();
System.out.println("winner is "+winner);
return true;
}
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race, "兔子").start();
new Thread(race, "乌龟").start();
}
}
方法三:实现Callable接口
实现Callable接口需要返回值类型,重写call方法,需要抛出异常。
优点:1.可以定义返回值;2.可以抛出异常。
创建目标对象
创建执行服务:ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行:Future result1 = ser.submit(t1);
获取结果:boolean r1 = result1.get();
关闭服务:ser.shutdownNow();
public class TestCallable implements Callable<Boolean>{
private String url;
private String name;
public TestThread(String url,String name){
this.url = url;
this.name = name;
}
@Override
public Boolean call(){
WebDownLoader webDownloder = new WebDownLoader();
webDownloder.downloder(url,name);
return true;
}
public static void main(String[] args){
TestCallable t1 = new TestCallable ("https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3403164926,2805624001&fm=26&gp=0.jpg","1.jpg");
t1.start();
ExecutorService ser = Executors.newFixedThreadPool(1);
Future<Boolean> r1= ser.submit(t1);
boolean rs1 = r1.get();
ser.shutdownNow();
}
}
class WebDownLoader{
public woid downloder(String url,String name){
try{
FileUtils.copyURLToFile(new URL(url), new File(name));
}catch(IOException e){
e.printStackTrace();
System.out.println("IO异常");
}
}
}
2.2 静态代理
静态代理模式:真实对象和代理对象都要实现同一个接口。代理对象要代理真实角色。
好处:代理对象可以做很多真实对象做不了的事情,真实对象专注做自己的事。
public class Dome1 {
public static void main(String[] args){
// 代理runnable接口
// new Thread(()->System.out.println("i love you")).start();
Company company = new Company(new You());
company.happymarry();
}
}
interface Marry {
void happymarry();
}
class You implements Marry {
@Override
public void happymarry() {
System.out.println("i am happy!");
}
}
class Company(You) implements Marry {
private Marry target; // 传真实对象
public Company(Marry target) {
this.target = target;
}
@Override
public void happymarry() {
before();
this.target.happymarry();
after();
}
public void before() {
System.out.println("prepare!");
}
public void after() {
System.out.println("we are happy!");
}
}
2.3 Lambda表达式
其实质属于函数式编程的概念,避免匿名内部类定义过多。
函数式接口的定义:任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。对于函数式接口,可以通过Lambda表达式来创建该接口的对象。
(params) -> expression[表达式]
(params) -> statement[语句]
(params) -> {statements}
a -> System.out.println("i like lambda-->" + a);
new Thread (()->System.out.println("多线程学习。。")).start();
//简化过程:
public class Test {
//3.静态内部类
static class Like2 implements iLike{
@Override
public void lambda() {
System.out.println("i like lambda2");
}
}
public static void main(String[] args) {
iLike like = new Like();
like.lambda(); //2.
like = new Like2();
like.lambda(); //3.
//4.局部内部类
class Like3 implements iLike{
@Override
public void lambda() {
System.out.println("i like lambda3");
}
like = new Like3();
like.lambda();//4.
//5.匿名内部类
like = new iLike() {//new 接口
@Override
public void lambda() {
System.out.println("i like lambda4");
}
};
like.lambda();
//6.用Lambda简化
like = ()->{
System.out.println("i like lambda5");
};//只有一行代码可以不用花括号
like.lambda();
}
}
//1.定义一个函数式接口
interface iLike{
void lambda();
}
//2.实现类
class Like implements iLike{
@Override
public void lambda() {
System.out.println("i like lambda");
}
}
3. 线程状态
- 创建状态
|启动线程 new - 就绪状态
|阻塞解除——获得CPU资源 - 阻塞状态
- 运行状态
|线程自然执行完毕或外部干涉终止线程 - 死亡状态
方法 | 说明 |
---|---|
setPriority(int newPriority) | 更改线程的优先级 |
static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
void join() | 等待该线程终止 |
static void yield() | 暂停当前正在执行的线程对象,并执行其他线程 |
void interrupt() | 中断线程,别用这个方式 |
boolean isAlive() | 测试线程是否处于活动状态 |
不推荐使用stop、destroy方法(已废弃);推荐线程自己停止下来——建议使用一个标志位进行终止变量,当flag=False,则终止线程运行。
public class Teststop implements Runnable {
//1.定义标识
private boolean flag = true;
@Override
public void run() {
//2.使用该标识
while (flag) {
System.out.println("run...Thread");
}
}
//3.对外提供方法改变标识
public void stop(){
this.flag = false;
}
}
3.1 线程休眠
- sleep指定当前线程阻塞的毫秒数,1000毫秒=1秒;
- sleep存在异常InterruptedException;
- sleep时间达到后线程进入就绪状态;
- sleep可以模拟网络延时、倒计时等;
- 每一个对象都有一个锁,sleep不会释放锁。
//模拟倒计时
public class Test {
public static void main(String[] args){
Date statTime = new Date(System.currentTimeMillis());
try {
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
tenDown();
statTime = new Date(System.currentTimeMillis());//更新时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void tenDown() throws InterruptedException {
int num = 10;
while (true) {
Thread.sleep(1000);
System.out.println(num--);
if (num == 0){
break;
}
}
}
}
3.2 线程礼让
让当前正在执行的线程暂停,但不阻塞,将线程从运行状态转为就绪状态,让CPU重新调度,礼让不一定成功,看CPU心情。
public class Test {
public static void main(String[] args) {
MyYield myyield = new MyYield();
new Thread(myyield,"a").start();
new Thread(myyield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程执行");
Thread.yield();
System.out.println(Thread.currentThread().getName()+"线程停止执行");
}
}
3.3 多线程强制执行join
Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞,类似于插队。
public class Test implements Runnable{
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
Thread thread = new Thread(test);
thread.start();
for (int i = 0; i < 100; i++) {
if (i == 50){
thread.join();
}
System.out.println("main...." + i);
}
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("join..." + i);
}
}
}
3.4 线程状态观测
Thread.State
- NEW:尚未启动的线程
- RUNNABLE:在JVM中执行的线程
- BLOCKED:被阻塞等监视器锁定的线程
- WAITING:正在等待另一个线程执行特定动作的线程
- TIMED WAITING:正在等待另一个线程执行动作达到指定等待时间的线程
- TERMINATED:已退出的线程
public class Test {
public static void main(String[] args) {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e){
e.printStackTrace();
}
}
System.out.println("/");
});
Thread.State state = thread.getState();
System.out.println(state);//NEW
thread.start();
state = thread.getState();
System.out.println(state);//RUN
while (state != Thread.State.TERMINATED){//只要线程不终止,一直输出
Thread.sleep(1000);
state = thread.getState();
System.out.println(state);
}
}
}
3.5 线程优先级
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字表示,范围从1-10.
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
使用以下方式改变或获取优先级getPriority()、setPriority(int xxx)。
先设置优先级再启动。性能倒置:优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用了,这都是看CPU的调度。
3.6 守护线程daemon
线程分为用户线程和守护线程。虚拟机必须确保用户线程执行完毕。虚拟机不用等待守护线程执行完毕,如后台记录操作日志、监控内存、垃圾回收等。
public class Test {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认是False为用户线程,正常线程都是用户线程
thread.start();
new Thread(you).start();
}
}
class God implements Runnable{
@Override
public void run(){
while (true) {
System.out.println("god blessing you");
}
}
}
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++){
System.out.println("happy living");
}
System.out.println("====goodbye:world!====");
}
4. 线程同步
4.1 线程同步
并发:同一个对象被多个线程同时操作。
线程同步是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待使用后释放锁即可。
存在以下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起;
- 在多线程竞争下,加锁、释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题。
synchronized关键字,它包括两种用法:synchronized方法和synchronized块。
- synchronized方法:
public synchronized void method(int args){}
- synchronized块:
synchronized(Obj){}
Obj称之为同步监视器,可以是任何对象,推荐使用共享资源作为同步监视器。同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者是class。
缺陷:若将一个大的方法申明为synchronized将会影响效率。
案例:买火车票
public class Test {
public static void main(String[] args){
BuyTicket station = new BuyTicket();
new Thread(station,"a").start();
new Thread(station,"b").start();
new Thread(station,"c").start();
}
class BuyTicket implements Runnable{
private int ticketNum = 10;//保证数据对象只能被方法访问,get/set
boolean flag = true;
@Override
public void run(){
while (flag){//线程停止
try{
buy();
} catch (InterruptedException e){
e.printStackTrace();
}
}
}
//同步方法,锁的是this
public synchronized void buy() throws InterruptedException {
if (ticketNum <= 0){
flag = false;
return;
}
Thread.sleep(100);//模拟延时可以放大问题的发生性
System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
}
}
4.2 JUC
import java.util.concurrent.CopyOnWriteArrayList;
public class Test {
public static void main(String[] args){
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
4.3 死锁
导致两个或者多个线程都在等待对方释放资源,都停止执行的情形,某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。
产生死锁的四个必要条件:(想办法避免其中一个或多个)
- 互斥条件:一个资源每次只能被一个进程使用;
- 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放;
- 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺;
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
4.4 Lock(锁)
从JDK5.0开始,Java提供了更强大的线程同步机制——通过显式定义同步锁Lock对象来实现同步。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
可重入锁ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁(synchronized是隐式锁,出了作用域自动释放)。
异同点:Lock只有代码块锁,synchronized有代码块锁和方法锁。使用Lock锁,JVM花费较少的时间来调度线程,性能更好,有更多扩展性(子类)。
优先顺序:Lock>同步代码块(已经进入方法体,分配了相应资源)>同步方法
class A {
private final ReentrantLock lock = new ReentrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码
}
finally{
lock.unlock();
//如果同步代码有异常,需要unlock写入finally语句块
}
}
}
5. 线程通信问题
生产者消费者问题:生产者和消费者共享同一个资源,并且生产者和消费者之间相互依赖,互为条件。
synchronized可阻止并发更新同一个共享资源,实现同步,但不能实现线程之间的消息传递。
方法名 | 作用(object类的方法,仅在同步方法或同步代码块中使用,否则抛出异常) |
---|---|
wait() | 表示线程一直等待,直到其他线程通知,与sleep不同,会释放锁 |
wait(long timeout) | 指定等待的毫秒数 |
notify() | 唤醒一个处于等待状态的线程 |
notifyAll() | 唤醒同一个对象上所有调用wait()方法的线程,优先级别高的线程优先调度 |
解决方法1:管程法——缓冲区
public class Test{
public static void main(String[] args){
SynContainer container = new SynContainer();
new Productor(container).start();
new Consumer(container).start();
}
}
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container){
this.container = container;
}
@Override
public void run(){
for (int i = 0; i < 100; i++){
container.push(new chicken(i));
System.out.println("生产了"+i+"只鸡");
}
}
}
class Consumer extends Thread{
SynContainer container;
public Productor(SynContainer container){
this.container = container;
}
@Override
public void run(){
for (int i=0; i<100;i++){
System.out.println("消费了"+container.pop().id+"只鸡");
}
}
}
class Chicken{
int id;
public Chicken(int id){
this.id = id;
}
}
class SynContainer{
Chicken[] chickens = new Chicken[10];//需要一个容器大小
int count = 0;//容器计数器
//生产者放入
public synchronized void push(Chicken chicken){
//如果容器满了
if (count==chickens.length){
try {
this.wait();//通知消费消费,生产者等待
}catch (InterruptedException e){
e.ptintStackTrace();
}
}
chickens[count] = chicken;//如果容器没有满
count++;
this.notifyAll();//通知消费者消费
}
//消费者消费
public synchronized Chicken pop(){
if (count==0){
try{//通知生产
this.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
count--;
Chicken chicken = chichens[count];
this.notifyAll();
return chicken;
}
解决方法2:信号灯法——标志位
public class Test(){
public static void main(String[] args){
Tv tv = new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
class Player extends Thread{
TV tv;
public Player(TV tv){
this.tv = tv;
}
@Override
public void run(){
for (int i=0; i<20; i++){
if(i%2==0){
this.tv.play("快乐大本营");
}else{
this.tv.play("天天向上");
}
}
}
}
class Watcher extends Thread{
TV tv;
public Player(TV tv){
this.tv = tv;
}
@Override
public void run(){
for (int i=0; i<20; i++){
tv.watch();
}
}
}
class TV{
String voice;
boolean flag = true;
public synchronized void play(String voice){
if(!flag){
try{
this.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
System.out.println("演员表演了"+voice);
this.voice = voice;
this.flag = !this.flag;
}
public synchronized void watch(){
if(flag){
try{
this.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
System.out.println("观众观看了"+voice);
this.notifyAll();
this.flag = !this.flag;
}
}
6. 高级主题
经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
线程池:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁,实现重复利用。
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止
JDK5.0提供了线程池相关API:
- ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
Futuresubmit(Callabletask):执行任务,有返回值,一般又来执行Callable
void shutdown():关闭连接池 - Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test{
public static void main(String[] args){
//1.创建服务,创建线程池:参数为线程池大小
ExecutorService service = Executors.newFixedThreadPool(10);
//2.执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//3.关闭链接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run(){
for(int i = 0; i<100; i++){
System.out.println(Thread.currentThread().getName()+i);
}
}
}
Semaphore类——限制线程并发的数量,否则CPU很快耗尽
private Semaphore semaphore = new Semaphore(permits:1);//构造函数参数permits是许可的意思,代表同一时间内,最多允许多少个线程同时执行acquire()和release()之间的代码。permits值如果大于1,并不能保证线程安全性,可能会出现多个线程共同访问实例变量,出现脏数据
public void testMethod() {
try {
semaphore.acquire();//无参方法,使用一个许可
//semaphore.acquire(int permits); 每调用1次此方法,就使用x个许可
//semaphore.acquireUninterruptibly(); 在等待许可的情况下不允许中断,如果成功获得锁,则取得指定的permits许可个数
System.out.println(Thread.currentThread().getName() + "begin timer=" + System.currentTimeMillis());
Thread.sleep(5000);
System.out.ptintln(Thread.currentThread().getName() + "end timer=" + System.currentTimeMillis());
semaphore.release();
//调用release()或release(int)可以动态增加permits的个数
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//availablePermits()返回此Semaphore对象中当前可用的许可数,用于调试
//drainPermits()获取并返回立即可用的所有许可个数,并将可用许可置0
//getQueueLength()取得等待许可的线程个数
//hasQueuedThreads()判断有没有线程在等待这个许可
有些时候,获得许可的顺序与线程启动的顺序有关,这时信号量就要分为公平与非公平的。所谓的公平信号量是获得锁的顺序与线程启动的顺序有关,但不代表100%地获得信号量,仅仅是在概率上能得到保证。而非公平信号量就是无关的了。
private boolean isFair = false;
private Semaphore semaphore = new Semaphore(permits:1, isFair);
- 无参方法tryAcquire()的作用是尝试地获得1个许可,如果获取不到则返回false,与if结合,具有无阻塞地特点,使线程不至于在同步处一直持续等待的状态。
- 有参方法tryAcquire(int permits)的作用是尝试地获得x个许可,如果获取不到则返回false。
- 有参方法tryAcquire(int long timeout, TimeUnit unit)的作用是在指定的时间内尝试地获得1个许可,如果获取不到则返回false。 如tryAcquire(3, TimeUnit.SECONDS)
- 有参方法tryAcquire(int permits, int long timeout, TimeUnit unit)的作用是在指定的时间内尝试地获得x个许可,如果获取不到则返回false。
private Semaphore semaphore = new Semaphore(permits:1);
public void testMethod() {
if (semaphore.tryAcquire()) {
System.out.println(Thread.currentThread().getName() + "begin timer=" + System.currentTimeMillis());
Thread.sleep(5000);
System.out.ptintln(Thread.currentThread().getName() + "end timer=" + System.currentTimeMillis());
semaphore.release();
} else {
System.out.println("ThreadName=" + Thread.currentThread().getName() + "未成功进入!");
}
}
- 多进路,多处理,多出路(多个线程同时处理自己的任务)
- 多进路,单处理,多出路(允许多个线程同时处理任务,但执行任务的顺序却是同步的/阻塞的)——加入ReentrantLock对象保证同步性
private Semaphore semaphore = new Semaphore(3);
private ReentrantLock lock = new ReentrantLock();
public void testMethod() {
try {
semaphore.acquire();
System.out.println("ThreadName=" + Thread.currentThread().getName() + "准备");
lock.lock();
System.out.println("begin hello " + System.currentTimeMillis());
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "打印" + (i+1));
}
System.out.println(" end hello" + System.currentTimeMillis());
lock.unlock;
semaphore.release();
System.out.println("ThreadName=" + Thread.currentThread().getName() + "结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
使用Semaphore创建字符串池:同时有若干个线程可以访问池中的数据,但同时只有一个线程可以取得数据,使用完毕后再放回池中。
package tools;
import java.util.ArrayList;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ListPool {
private int poolMaxSize = 3;
private int semaphorePermits = 5;
private List<String> list = new ArrayList<String>();
private Semaphore concurrencySemaphore = new Semaphore(semaphorePermits);
private ReentrantLock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public ListPool() {
super();
for (int i = 0; i < poolMaxSize; i++) {
list.add("zzz" + (i + 1));
}
}
public String get() {
String getString = null;
try {
concurrencySemaphore.acquire();
lock.lock();
while(list.size() == 0) {
condition.await();
}
getString = list.remove(0);
lock.unlock();
} catch (InterruptedException e) {
e.printStackTrace();
}
return getString;
}
public void put(String stringValue) {
lock.lock();
list.add(stringValue);
condition.signalAll();
lock.unlock();
concurrencySemaphore.release();
}
}
package extthread;
import tools.ListPool;
public class MyThread extends Thread {
private ListPool listPool;
public MyThread(ListPool listPool) {
super();
this.listPool = listPool;
}
@Override
public void run() {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
String getString = listPool.get();
System.out.println(Thread.currentThread().getName() + "取得值" + getString);
listPool.put(getString);
}
}
}
package test;
import tools.ListPool;
import extthread.MyThread;
public class Run {
public static void main(String[] args) {
ListPool pool = new ListPool();
MyThread[] threadArray = new MyThread[12];
for (int i = 0; i < threadArray.length; i++) {
threadArray[i] = new MyThread(pool);
}
for (int i = 0; i < threadArray.length; i++) {
threadArray[i].start();
}
}
}
多生产者/多消费者模式:
package service;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Conditon;
import java.util.concurrent.locks.ReentrantLock;
public class RepastService {
volatile private Semaphore setSemaphore = new Semaphore(10);//厨师
volatile private Semaphore getSemaphore = new Semaphore(20);//就餐
volatile private ReentrantLock lock = new ReentrantLock();
volatile private Condition setCondition = lock.newCondition();
volatile private Condition getCondition = lock.newCondition();
//producePosition变量的含义是最多只有4个盒子存放菜品
volatile private Object[] producePosition = new Object[4];
private boolean isEmpty() {
boolean isEmpty = true;
for (int i = 0; i < producePosition.length; i++) {
if (producePosition[i] != null) {
isEmpty = false;
break;
}
}
if (isEmpty == true) {
return true;
} else {
return false;
}
}
private boolean isFull() {
boolean isFull = true;
for (int i = 0; i < producePosition.length; i++) {
if (producePosition[i] == null) {
isFull = false;
break;
}
}
return isFull;
}
public void set() {
try {
setSemaphore.acquire();//允许同时最多有10个厨师生产
lock.lock();
while (isFull()) {
setCondition.await();
}
for (int i = 0; i < producePosition.length; i++) {
if (producePosition[i] == null) {
producePosition[i] = "数据";
System.out.println(Thread.currentThread().getName() + "生产了" + producePosition[i]);
break;
}
}
getCondition.signalAll();
lock.unlock();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
setSemaphore.release();
}
}
public void get() {
try {
getSemaphore.acquire();
lock.lock();
while (isEmpty()) {
getCondition.await();
}
for (int i = 0; i < producePosition.length; i++) {
if (producePosition[i] != null) {
System.out.println(Thread.currentThread().getName() + "消费了" + producePosition[i]);
producePosition[i] = null;
break;
}
}
setCondition.signalAll();
lock.unlock();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
getSemaphore.release();
}
}
}
package test.run;
import service.RepastService;
import extthread.ThreadC;
import extthread.ThreadP;
public class Run {
public static void main(String[] args) throws InterruptedException {
RepastService service = new RepastService();
ThreadP[] arrayP = new ThreadP[60];
ThreadC[] arrayC = new ThreadC[60];
for (int i = 0; i < 60; i++) {
arrayP[i] = new ThreadP(service);
arrayC[i] = new ThreadC(service);
}
Thread.sleep(2000);
for (int i = 0; i < 60; i++) {
arrayP[i].start();
arrayC[i].start();
}
}
}
Exchanger类——2个线程之间传递任意数据类型的数据
exchange()方法具有阻塞的特色,被调用后等待其他线程来取得数据,如果没有其他线程取得数据,则一直阻塞等待。
package extthread;
import java.util.concurrent.Exchanger;
public class ThreadA extends Thread {
private Exchanger<String> exchanger;
public ThreadA(Exchanger<String> exchanger) {
super();
this.exchanger = exchanger;
}
@Override
public void run() {
try {
System.out.println("在线程A中得到线程B的值=" + exchanger.exchange("中国人A"));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
CountDownLatch类——控制线程执行任务时机,使线程以”组团“的方式执行任务
计数无法被重置,如果需要重置计数,用CyclicBarrier类。
package service;
import java.util.concurrent.CountDownLatch;
public class MyService {
private CountDownLatch down = new CountDownLatch(1);//创建1个计数的CountDownLatch类的对象
public void testMethod() {
try {
System.out.println("A");
down.await();//判断计数是否为0,不为0则呈等待状态
System.out.println("B");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void downMethod() {
System.out.pritnln("X");
down.countDown();//将计数减1,减为0等待线程继续运行
}
}
裁判等全部运动员:
package extthread;
import java.util.concurrent.CountDownLatch;
public class MyThread extends Thread {
private CountDownLatch maxRuner;
public MyThread(CountDownLatch maxRuner) {
super();
this.maxRunner = maxRuner;
}
@Override
public void run() {
try {
Thread.sleep(2000);
maxRuner.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
package test.run;
import java.util.concurrent.CountDownLatch;
import extthread.MyThread;
public class Run {
public static void main(String[] args) throws InterruptedException {
CountDownLatch maxRuner = new CountDownLatch(10);
MyThread[] tArray = new MyThread[Integer.parseInt(""+maxRuner.getCount())];//获取当前计数值
for (int i = 0; i < tArray.length; i++) {
tArray[i] = new MyThread(maxRuner);
tArray[i].setName("线程"+(i+1));
tArray[i].start();
}
maxRuner.await();
System.out.println("都回来了");
}
}
CyclicBarrier类——阶段性同步,实现线程一起做任务
允许一组线程互相等待,直到到达某个公共屏障点。
CountDownLatch类与CyclicBarrier类的区别:1)CountDownLatch作用:一个线程或者多个线程,等待另外一个线程或多个线程完成某个事情之后才能继续执行;2)CyclicBarrier的作用:多个线程之间相互等待,任何一个线程完成之前,所有的线程都必须等待,即“多个线程之间”任何一个线程没有完成任务,则所有的线程必须等待。