Java并发编程学习(6)---并发编程工具类(三)

最新推荐文章于 2022-11-11 13:06:32 发布

左撇子帕布

最新推荐文章于 2022-11-11 13:06:32 发布

阅读量232

点赞数

分类专栏： Java能力提升文章标签： semaphore FutureTask

本文链接：https://blog.csdn.net/u011294519/article/details/88386421

版权

Java能力提升专栏收录该内容

31 篇文章 2 订阅

订阅专栏

目录页：https://blog.csdn.net/u011294519/article/details/88367808

1.Semaphore

当一个线程想要访问一个由semaphore保护的共享资源时，首先，它必须获取semaphore。如果semaphore的内部计数器大于0，则semaphore对计数器进行递减，并允许访问共享资源。如果semaphore的计数器为0，则semaphore将线程休眠，直到计数器大于0。

显然，semaphore不仅仅是计数器。当计数器的值为零时，它们可以让线程等待，也就是说，它们充当具有计数器功能的锁。

1.1.Semaphore主要方法

Semaphore(int permits):构造方法，创建具有给定许可数的计数信号量并设置为非公平信号量。

Semaphore(int permits,boolean fair):构造方法，当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量。

void acquire():从此信号量获取一个许可前线程将一直阻塞。

void acquire(int n):从此信号量获取给定数目许可，在提供这些许可前一直将线程阻塞。

void release():释放一个许可，将其返回给信号量。就如同车开走返回一个车位。

void release(int n):释放n个许可。

int availablePermits()：当前可用的许可数。

1.2.示例代码

以打印机为例子，假设有3台打印机，这时打印机资源就是共享资源，所以构造semaphore时传入参数为3

打印机队列类，这个类有3个主要属性，它们控制从3个打印机中选择一个空闲打印机并锁定它来打印作业的逻辑。

package com.concurrent.coline.part6.semaphore.printer;

import java.util.Date;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class PrinterQueue {
    //This Semaphore will keep track of no. of printers used at any point of time.
    private final Semaphore semaphore;

    //While checking/acquiring a free printer out of three available printers, we will use this lock.
    private final Lock printerLock;

    //This array represents the pool of free printers.
    private boolean freePrinters[];

    public PrinterQueue() {
        semaphore = new Semaphore(3);
        freePrinters = new boolean[3];
        for (int i = 0; i < 3; i++) {
            freePrinters[i] = true;
        }
        printerLock = new ReentrantLock();
    }

    public void printJob() {
        try {
            //Decrease the semaphore counter to mark a printer busy
            System.out.printf("Now wait queue num : %s \n", semaphore.getQueueLength());
            semaphore.acquire();
            System.out.printf("when %s in available permites %s \n", Thread.currentThread().getName(), semaphore.availablePermits());
            //Get the free printer
            int assignedPrinter = getPrinter();

            //Print the job
            Long duration = (long) (Math.random() * 10000);
            System.out.println(Thread.currentThread().getName()
                    + ": Printer " + assignedPrinter
                    + " : Printing a Job during " + (duration / 1000)
                    + " seconds :: Time - " + new Date());
            Thread.sleep(duration);

            //Printing is done; Free the printer to be used by other threads.
            releasePrinter(assignedPrinter);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.printf("%s: The document has been printed\n", Thread
                    .currentThread().getName());

            //Increase the semaphore counter back
            semaphore.release();
        }
    }

    //Acquire a free printer for printing a job
    private int getPrinter() {
        int foundPrinter = -1;
        try {
            //Get a lock here so that only one thread can go beyond this at a time
            printerLock.lock();

            //Check which printer is free
            for (int i = 0; i < freePrinters.length; i++) {
                //If free printer found then mark it busy
                if (freePrinters[i]) {
                    foundPrinter = i;
                    freePrinters[i] = false;
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //Allow other threads to check for free priniter
            printerLock.unlock();
        }
        return foundPrinter;
    }

    //Release the printer
    private void releasePrinter(int i) {
        printerLock.lock();
        //Mark the printer free
        freePrinters[i] = true;
        printerLock.unlock();
    }
}

打印类

package com.concurrent.coline.part6.semaphore.printer;

public class PrintingJob implements Runnable {
    private PrinterQueue printerQueue;

    public PrintingJob(PrinterQueue printerQueue) {
        this.printerQueue = printerQueue;
    }

    @Override
    public void run() {
        System.out.printf("%s: Going to print a document\n", Thread
                .currentThread().getName());
        printerQueue.printJob();
    }
}

测试类

package com.concurrent.coline.part6.semaphore.printer;

public class Apptest {
    public static void main(String[] args) {
        PrinterQueue printerQueue = new PrinterQueue();
        Thread thread[] = new Thread[10];
        for (int i = 0; i < 10; i++) {
            thread[i] = new Thread(new PrintingJob(printerQueue), "Thread " + i);
        }
        for (int i = 0; i < 10; i++) {
            thread[i].start();
        }
    }
}

源码在concurrent-toolbar模块的part6

因为打印了太多东西，执行结果我就不截图出来了

1.3.查看源码环节

构造方法：一路进入源码，发现最终是使用AQS的setStatus方法，这个跟CountDownLatch是一样的

这个status是使用volatile关键字修饰，在我之前的博文说过，保证可见性，不保证原子性。

acquire()方法：一路进入方法

在这里semaphore获取剩余资源量，并重新设置state，这里的AQS的compareAndSetState写法看上去很神奇，以后写代码可以参考。

release()方法：

还是一路进代码

发现大神很喜欢使用自旋来保证代码执行，我在平时写代码时除了获取kafka消息时基本不敢使用死循环，总感觉怕怕的。

2.FutureTask

2.1.主要方法

public FutureTask(Callable<V> callable)，这个是我们经常用的构造方法，传入Callable创建一个FutureTask，Callable有返回值，可以抛出异常。
public FutureTask(Runnable runnable, V result)，这个构造函数很有意思，如果使用这个构造函数创建出FutureTask，在get的时候其实返回的是传入的result，个人理解是在你想使用runnable（不需要返回值，不需要抛出异常）的时候，需要满足线程的并发执行，又要保证线程全部执行完成后再执行后续业务代码时使用。
get()：获取线程执行完成的返回值
cancel()：中断FutureTask，注意，java的线程都是协作式的，所以这边的cancel并不是说调用了就干掉这个FutureTask实例，而是设置该实例的state值作为标识，这个有兴趣的可以看源码。

2.2.示例代码

package com.concurrent.coline.part6.future;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 类说明：演示Future等的使用
 */
public class UseFuture {
    /*实现Callable接口，允许有返回值*/
    private static class UseCallable implements Callable<Integer> {
        private int sum;

        @Override
        public Integer call() throws Exception {
            System.out.println("Callable子线程开始计算");
            Thread.sleep(2000);
            for (int i = 0; i < 5000; i++) {
                sum = sum + i;
            }
            System.out.println("Callable子线程计算完成，结果=" + sum);
            return sum;
        }

    }

    private static class UseRunnable implements Runnable {
        private int sum;

        @Override
        public void run() {
            System.out.println("UseRunnable子线程开始计算");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 5000; i++) {
                sum = sum + i;
            }
        }
    }

    public static void main(String[] args)
            throws InterruptedException, ExecutionException {

        UseCallable useCallable = new UseCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(useCallable);
        new Thread(futureTask).start();
        Random r = new Random();
        //随机决定是获得结果还是终止任务
        if (r.nextBoolean()) {
            System.out.println("Get UseCallable result = " + futureTask.get());
        } else {
            System.out.printf("中断计算 flag: %s \n", futureTask.cancel(true));
        }

        /*
          个人理解使用runnable初始化FutureTask目的是为了并发执行线程的同时保证后续的业务执行顺序
         */
        UseRunnable useRunnable = new UseRunnable();
        FutureTask<Integer> runnableFutureTask = new FutureTask(useRunnable, 1);
        new Thread(runnableFutureTask).start();
        System.out.println("runnableFutureTask get " + runnableFutureTask.get());
        System.out.println("main ended");
    }

}

源码在concurrent-toolbar模块的part6

运行结果：