java并发编程实践笔记三

最新推荐文章于 2024-01-28 14:32:37 发布
最新推荐文章于 2024-01-28 14:32:37 发布
阅读量635 收藏
点赞数
分类专栏： 并发编程 文章标签： 并发编程 java并发编程实践
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liao_hb/article/details/82840700
版权

目录

任务和线程

任务处理框架（Executor）

用Executor框架实现 “每任务每线程”和顺序执行这2种调度策略的服务器

执行策略

Executor中的线程池

Executor中任务的生命周期管理

延迟任务与周期任务-ScheduledExecutorService

找出可利用的并行性-HTML渲染器

处理线程的非正常结束

线程泄漏

线程未捕获的异常

关闭JVM

关闭钩子

守护线程

终结器

任务和线程

下面讨论服务器使用线程这种工具来调度任务的问题。

顺序地执行任务：

/**
 * SingleThreadWebServer
 * <p/>
 * Sequential web server
 *
 * @author Brian Goetz and Tim Peierls
 */

public class SingleThreadWebServer {
    public static void main(String[] args) throws IOException {
        ServerSocket socket = new ServerSocket(80);
        while (true) {
            Socket connection = socket.accept();
            handleRequest(connection);
        }
    }

    private static void handleRequest(Socket connection) {
        // request-handling logic here
    }
}

一个web请求的处理，可能包括执行运算，处理文件IO，发送数据库请求，都耗时较长，而且由于网络拥堵和连通性问题，服务器读取请求和写回响应都会阻塞，明显吞吐率极低，而且若这种单线程正在吹文件IO，那么CPU将处于闲置状态，明显资源利用率也极低。

所以，为每个请求任务创建线程：

/**
 * ThreadPerTaskWebServer
 * <p/>
 * Web server that starts a new thread for each request
 *
 * @author Brian Goetz and Tim Peierls
 */
public class ThreadPerTaskWebServer {
    public static void main(String[] args) throws IOException {
        ServerSocket socket = new ServerSocket(80);
        while (true) {
            final Socket connection = socket.accept();
            Runnable task = new Runnable() {
                public void run() {
                    handleRequest(connection);
                }
            };
            new Thread(task).start();
        }
    }

    private static void handleRequest(Socket connection) {
        // request-handling logic here
    }
}

我们把它叫做“每任务每线程”的调度策略。可以看出，1.任务的负载脱离了主线程，2.可以并行处理阻塞性的任务，3.任务处理必须安全，4.吞吐率和资源利用率得到提升。

但是，1.线程的创建和关闭需要时间，如果请求是频繁的，就会消耗大量的计算资源；2.运行的线程多余可用的处理器，导致大量的空闲线程占用更多的内存，大量线程在竞争CPU时，会产生性能开销，这都消耗资源和性能；3.线程数目多会打破栈的限制，可能会抛出outofmemoryError，影响程序的稳定性，每个线程会维护2个栈，一个java层，一个native层的，而且每个线程的栈地址空间是固定的，可以预设，当你的线程越多时，就有可能突破内存的大小。这些都是不约束线程的创建带来的效果。

总结，一个线程顺序地处理所有任务产生糟糕的响应性和吞吐率，“每任务每线程”会给资源管理（内存，cpu等等）带来麻烦。所以任务处理框架，尤其例如Executor应运而生。

任务处理框架（Executor）

用Executor框架实现 “每任务每线程”和顺序执行这2种调度策略的服务器

/**
* @since 1.5
 	* @author Doug Lea
 	*/ 
public interface Executor {
    void execute(Runnable command);
}

这个简约的接口是Executor框架的基础，而Executor框架可用于处理异步任务，支持不同类型的任务执行策略，它解耦了任务提交和任务执行，包装Runnable来描述任务，还提供了任务的生命周期服务，当然还有线程池的实现，以及其他扩展功能。

接下来我们用Executor来实现“每任务每线程”这种调度策略的服务器：

/**
 * TaskExecutionWebServer
 * <p/>
 * Web server using a thread pool
 *
 * @author Brian Goetz and Tim Peierls
 */
public class TaskExecutionWebServer {
    private static final int NTHREADS = 100;
    private static final Executor exec = Executors.newFixedThreadPool(NTHREADS);

    public static void main(String[] args) throws IOException {
        ServerSocket socket = new ServerSocket(80);
        while (true) {
            final Socket connection = socket.accept();
            Runnable task = new Runnable() {
                public void run() {
                    handleRequest(connection);
                }
            };
            exec.execute(task);
        }
    }

    private static void handleRequest(Socket connection) {
        // request-handling logic here
    }
}

如果我们把上例中的Executor换成下面的ThreadPerTaskExecutor，这样就实现了“每任务每线程”这种调度策略的服务器。

/**
 * ThreadPerTaskExecutor
 * <p/>
 * Executor that starts a new thread for each task
 *
 * @author Brian Goetz and Tim Peierls
 */
public class ThreadPerTaskExecutor implements Executor {
    public void execute(Runnable r) {
        new Thread(r).start();
    };
}
下面的WithinThreadExecutor实现了顺序执行任务这种调度策略。
/**
 * WithinThreadExecutor 
 * <p/>
 * Executor that executes tasks synchronously in the calling thread
 *
 * @author Brian Goetz and Tim Peierls
 */
public class WithinThreadExecutor implements Executor {
    public void execute(Runnable r) {
        r.run();
    };
}

执行策略

执行策略之所以可以定制，是因为Executor框架解耦了任务提交和任务执行。一个执行策略包括：

任务在什么（what）线程中执行。

任务以什么（what）顺序执行（FIFO，LIFO，优先级）。

可以有多少个（how many）任务并发。

可以有多少个（how many）任务进入等待执行队列。

如果系统过载，如果要放弃任务，应该挑选哪一个（which）任务。挑选的这个任务如何（how）让应用程序知道（抛异常，还是回调等）。

在一个任务执行前和结束后应该做些什么（what）。

所谓的最佳策略，取决于可用的计算资源和你对服务质量的需求。把任务提交和任务执行分离，让策略更好地为控制任务执行。

Executor中的线程池

线程池和任务队列紧密相关。任务队列持有所有等待执行的任务，而线程池里的线程会从任务队列中获取一个任务并执行，然后归还到线程池并等待下一个任务。

使用Executor有许多优势，具体见java编程实践的第6章6.2.3的叙述，这里列出创建Executor的一些方式，创建的Executor具体怎么使用也详见java编程实践的第6章6.2.3的叙述。

 

Executor中任务的生命周期管理

JVM只有在所有非守护线程全部终止后才退出，因此，无法正确地关闭Executor，JVM就无法退出。为了解决Executor的生命周期管理问题，ExecutorService接口提上了日程：

public interface ExecutorService extends Executor

这些方法具体的定义和内容详见java编程实践的第6章6.2.3的叙述，在此略过。下面举一个用到其中方法的例子：

/**
 * LifecycleWebServer
 * <p/>
 * Web server with shutdown support
 *
 * @author Brian Goetz and Tim Peierls
 */
public class LifecycleWebServer {
    private final ExecutorService exec = Executors.newCachedThreadPool();

    public void start() throws IOException {
        ServerSocket socket = new ServerSocket(80);
        while (!exec.isShutdown()) {
            try {
                final Socket conn = socket.accept();
                exec.execute(new Runnable() {
                    public void run() {
                        handleRequest(conn);
                    }
                });
            } catch (RejectedExecutionException e) {
                if (!exec.isShutdown())
                    log("task submission rejected", e);
            }
        }
    }

    public void stop() {
        exec.shutdown();
    }

    private void log(String msg, Exception e) {
        Logger.getAnonymousLogger().log(Level.WARNING, msg, e);
    }

    void handleRequest(Socket connection) {
        Request req = readRequest(connection);
        if (isShutdownRequest(req))
            stop();
        else
            dispatchRequest(req);
    }

    interface Request {
    }

    private Request readRequest(Socket s) {
        return null;
    }

    private void dispatchRequest(Request r) {
    }

    private boolean isShutdownRequest(Request r) {
        return false;
    }
}

延迟任务与周期任务-ScheduledExecutorService

使用Doug Lea 的ScheduledExecutorService 接口，延迟任务执行和周期性地执行。

public interface ScheduledExecutorService extends ExecutorService

不要使用Josh Bloch的Timer和TimerTask，他们有缺陷（详见6.2.2），如下例：程序运行1秒就结束了，说好的6秒呢，第一个TimerTask抛出异常后也会传染到第二个TimerTask。

/**
 * OutOfTime
 * <p/>
 * Class illustrating confusing Timer behavior
 *
 * @author Brian Goetz and Tim Peierls
 */

public class OutOfTime {
    public static void main(String[] args) throws Exception {
        Timer timer = new Timer();
        timer.schedule(new ThrowTask(), 1);
        SECONDS.sleep(1);
        timer.schedule(new ThrowTask(), 1);
        SECONDS.sleep(5);
    }

    static class ThrowTask extends TimerTask {
        public void run() {
            throw new RuntimeException();
        }
    }
}

 

找出可利用的并行性-HTML渲染器

下面的程序串行地渲染页面元素：渲染文本-下载所有图片-渲染所有图片

/**
 * SingleThreadRendere
 * <p/>
 * Rendering page elements sequentially
 *
 * @author Brian Goetz and Tim Peierls
 */
public abstract class SingleThreadRenderer {
    void renderPage(CharSequence source) {
        renderText(source);
        List<ImageData> imageData = new ArrayList<ImageData>();
        for (ImageInfo imageInfo : scanForImageInfo(source))
            imageData.add(imageInfo.downloadImage());
        for (ImageData data : imageData)
            renderImage(data);
    }

    interface ImageData {
    }

    interface ImageInfo {
        ImageData downloadImage();
    }

    abstract void renderText(CharSequence s);
    abstract List<ImageInfo> scanForImageInfo(CharSequence s);
    abstract void renderImage(ImageData i);
}

使用Future等待所有图片下载完成后再渲染所有图片，让下载所有图片和渲染文本并行：

/**
 * FutureRenderer
 * <p/>
 * Waiting for image download with \Future
 *
 * @author Brian Goetz and Tim Peierls
 */
public abstract class FutureRenderer {
    private final ExecutorService executor = Executors.newCachedThreadPool();

    void renderPage(CharSequence source) {
        final List<ImageInfo> imageInfos = scanForImageInfo(source);
        Callable<List<ImageData>> task =
                new Callable<List<ImageData>>() {
                    public List<ImageData> call() {
                        List<ImageData> result = new ArrayList<ImageData>();
                        for (ImageInfo imageInfo : imageInfos)
                            result.add(imageInfo.downloadImage());
                        return result;
                    }
                };

        Future<List<ImageData>> future = executor.submit(task);
        renderText(source);

        try {
            List<ImageData> imageData = future.get();
            for (ImageData data : imageData)
                renderImage(data);
        } catch (InterruptedException e) {
            // Re-assert the thread's interrupted status
            Thread.currentThread().interrupt();
            // We don't need the result, so cancel the task too
            future.cancel(true);
        } catch (ExecutionException e) {
            throw launderThrowable(e.getCause());
        }
    }

    interface ImageData {
    }

    interface ImageInfo {
        ImageData downloadImage();
    }

    abstract void renderText(CharSequence s);

    abstract List<ImageInfo> scanForImageInfo(CharSequence s);

    abstract void renderImage(ImageData i);
}

分析上面的程序，使用2个线程分摊任务至多能将速度提升一倍，然而渲染文本的速度可能远远高于下载图像的速度，那么程序最终性能与串行执行的性能差别不大，代码还变复杂了，所以只有大量相互独立且同构的任务并发时，才能让性能真正提升。独立且同构的任务的分解变的异常重要。

然而，我们希望做的更好，每下载完一张图片，就渲染一张。

顺着使用Future的思路，我们可能会想到提交多个下载图片的task到Executor执行器，得到一组Future，然后串行遍历这一组Future一一获取结果再渲染，这样做会有什么性能问题吗？把下载时间最短任务排队头和把下载时间最长的排对头，似乎有些区别，把下载时间最长的排对头在获取其他任务结果的时候，如果其他任务已经下载完，则get方法不用在内部调用获取锁和释放锁的操作而是直接返回结果，把下载时间最长的排对头，可能得到其余的下载任务中直接返回结果的最多，从而在锁的获取与释放上节省一批时间；但是如何得知下载任务里哪一个下载时间最长，恐怕这不仅与文件大小有关还也要和当时的网络环境有关。所以串行遍历这一组Future的耗时和他们的排序有关，而如何排序显得格外棘手。最好的做法是把下载的情况通知给外边。然而，java并发实践给出另一种方案：使用concurrent包里的CompletionService，它实现了多线程中的生产者和消费者模式，使用submit提交任务生产产品，使用take和poll来异步地消费产品，其实现机制是使用Executor和BlockingQueue来组合实现，Executor把异步生产完成的产品异步地放入BlockingQueue（在FutureTask的done方法里放入），然后我们用CompletionService的get方法去BlockingQueue里获取。因此：

/**
 * Renderer
 * <p/>
 * Using CompletionService to render page elements as they become available
 *
 * @author Brian Goetz and Tim Peierls
 */
public abstract class Renderer {
    private final ExecutorService executor;

    Renderer(ExecutorService executor) {
        this.executor = executor;
    }

    void renderPage(CharSequence source) {
        final List<ImageInfo> info = scanForImageInfo(source);
        CompletionService<ImageData> completionService =
                new ExecutorCompletionService<ImageData>(executor);
        for (final ImageInfo imageInfo : info)
            completionService.submit(new Callable<ImageData>() {
                public ImageData call() {
                    return imageInfo.downloadImage();
                }
            });

        renderText(source);

        try {
            for (int t = 0, n = info.size(); t < n; t++) {
                Future<ImageData> f = completionService.take();
                ImageData imageData = f.get();
                renderImage(imageData);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (ExecutionException e) {
            throw launderThrowable(e.getCause());
        }
    }

    interface ImageData {
    }

    interface ImageInfo {
        ImageData downloadImage();
    }

    abstract void renderText(CharSequence s);

    abstract List<ImageInfo> scanForImageInfo(CharSequence s);

    abstract void renderImage(ImageData i);

}

在指定的时间内获取广告信息（任务的获取有时长限制）：

/**
 * RenderWithTimeBudget
 *
 * Fetching an advertisement with a time budget
 *
 * @author Brian Goetz and Tim Peierls
 */
public class RenderWithTimeBudget {
    private static final Ad DEFAULT_AD = new Ad();
    private static final long TIME_BUDGET = 1000;
    private static final ExecutorService exec = Executors.newCachedThreadPool();

    Page renderPageWithAd() throws InterruptedException {
        long endNanos = System.nanoTime() + TIME_BUDGET;
        Future<Ad> f = exec.submit(new FetchAdTask());
        // Render the page while waiting for the ad
        Page page = renderPageBody();
        Ad ad;
        try {
            // Only wait for the remaining time budget
            long timeLeft = endNanos - System.nanoTime();
            ad = f.get(timeLeft, NANOSECONDS);
        } catch (ExecutionException e) {
            ad = DEFAULT_AD;
        } catch (TimeoutException e) {
            ad = DEFAULT_AD;
            f.cancel(true);
        }
        page.setAd(ad);
        return page;
    }

    Page renderPageBody() { return new Page(); }


    static class Ad {
    }

    static class Page {
        public void setAd(Ad ad) { }
    }

    static class FetchAdTask implements Callable<Ad> {
        public Ad call() {
            return new Ad();
        }
    }

}

可以为批量的任务设置超时时限，旅行门户网站订票信息显示，输入旅程的相关参数，就会显示来自各个航行运输公司的票务，路线信息，而为了及时响应，就不能等待一个获取时间特别长的信息后再统一显示，这时候就要统一设置这些任务的超时时长。

/**
 * QuoteTask
 * <p/>
 * Requesting travel quotes under a time budget
 *
 * @author Brian Goetz and Tim Peierls
 */
public class TimeBudget {
    private static ExecutorService exec = Executors.newCachedThreadPool();

    public List<TravelQuote> getRankedTravelQuotes(TravelInfo travelInfo, Set<TravelCompany> companies,
                                                   Comparator<TravelQuote> ranking, long time, TimeUnit unit)
            throws InterruptedException {
        List<QuoteTask> tasks = new ArrayList<QuoteTask>();
        for (TravelCompany company : companies)
            tasks.add(new QuoteTask(company, travelInfo));

        List<Future<TravelQuote>> futures = exec.invokeAll(tasks, time, unit);

        List<TravelQuote> quotes =
                new ArrayList<TravelQuote>(tasks.size());
        Iterator<QuoteTask> taskIter = tasks.iterator();
        for (Future<TravelQuote> f : futures) {
            QuoteTask task = taskIter.next();
            try {
                quotes.add(f.get());
            } catch (ExecutionException e) {
                quotes.add(task.getFailureQuote(e.getCause()));
            } catch (CancellationException e) {
                quotes.add(task.getTimeoutQuote(e));
            }
        }

        Collections.sort(quotes, ranking);
        return quotes;
    }

}

class QuoteTask implements Callable<TravelQuote> {
    private final TravelCompany company;
    private final TravelInfo travelInfo;

    public QuoteTask(TravelCompany company, TravelInfo travelInfo) {
        this.company = company;
        this.travelInfo = travelInfo;
    }

    TravelQuote getFailureQuote(Throwable t) {
        return null;
    }

    TravelQuote getTimeoutQuote(CancellationException e) {
        return null;
    }

    public TravelQuote call() throws Exception {
        return company.solicitQuote(travelInfo);
    }
}

interface TravelCompany {
    TravelQuote solicitQuote(TravelInfo travelInfo) throws Exception;
}

interface TravelQuote {
}

interface TravelInfo {
}

处理线程的非正常结束

线程泄漏

线程泄漏，在线程池服务框架中，如果有一个线程因为RunTimeException未加处理而是默认地在控制台中输出栈追踪信息，并终止线程，这样的终止线程有可能是恶性的。 Timer的缺陷就是线程泄漏，可以参见前面的OutOfTimer类。

如下例，一个典型的线程池工作者线程结构，如果抛出的是一个未检查异常，首先会通知框架该线程已终止，然后框架可能会启用新的线程，或者不会启用新线程，或者当前有足够多的线程，或者怎么着等等。大家可以看看Worker的实现如下：

大家可以看看Worker的实现如下：

    final void runWorker(Worker w) {
        ……
boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
               	…….
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                   	……
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

 

线程未捕获的异常

         未处理的异常可以通过设置线程的UncaughtExceptionHandler，从而把未检查的异常信息最终传递到UncaughtExceptionHandler，如果没有设置UncaughtExceptionHandler，则默认行为是将栈追踪信息输出到System.err。通常情况下，线程池里所有线程都转向同一个UncaughtExceptionHandler，并且该处理器至少将异常信息记录到日志文件中。

/**
 * UEHLogger
 * <p/>
 * UncaughtExceptionHandler that logs the exception
 *
 * @author Brian Goetz and Tim Peierls
 */
public class UEHLogger implements Thread.UncaughtExceptionHandler {
    public void uncaughtException(Thread t, Throwable e) {
        Logger logger = Logger.getAnonymousLogger();
        logger.log(Level.SEVERE, "Thread terminated with exception: " + t.getName(), e);
    }
}

 在Executor框架中，可用ThreadFactory统一为线程设置UncaughtExceptionHandler。

关闭JVM

         JVM既可以正常关闭，也可以强行关闭。正常关闭的触发方式有多种，包括：当最后一个“正常（非守护）”线程结束时，或者当调用了System.exit时，或者通过其他特定于平台的方法关闭时（例如发送了SIGINT信号或者键入Ctrl-C）。强行关闭包括:通过调用Runtime.halt或者在操作系统中“杀死”JVM进程(例如发送SIGKILL)。

关闭钩子

是指通过Runtime.addShutdownHook注册的但尚未开始的线程。

在正常关闭中，jvm首先调用所有已注册的关闭钩子，并不能保证关闭钩子的调用顺序。

在关闭应用程序时，如果有（守护或非守护）线程仍然在运行，那么这些线程将与关闭进程并发。jvm并不会停止或中断任何在关闭时仍然运行的应用程序线程。

当所有关闭钩子都执行结束时，如果runFinalizersOnExit为true，那么jvm将运行终结器，然后再停止。

当jvm最终结束时，这些线程将被强行结束。

如果关闭钩子或终结器没有执行完成，那么正常关闭进程挂起并且JVM必须强行关闭。

强行关闭JVM时，只是关闭JVM，不会运行关闭钩子。

关闭钩子不应该对应用程序的状态（如：其它服务是否已经关闭，或者 所有正常线程是否已经执行完成）或者对jvm的关闭原因做出假设，为的是关闭钩子应该尽快完成并退出，避免他们延迟jvm的结束时间。

注册的关闭钩子，未执行完的应用程序的线程，关闭进程他们是并发的。关闭钩子应该要线程安全，它们在访问共享数据时必须使用同步机制，并且避免发生死锁。看一个例子：

一个关闭日志服务的钩子。

关闭钩子是并发的，关闭日志服务可能会影响其他需要日志服务的钩子。为了避免避免这种依赖，或者说并发的情况，我们让所有服务使用同一个钩子，让所有服务的关闭操作在一个钩子内串行执行，可以确保关闭操作按照正确地顺序执行。

下面是测试类：

public class TestMyHook {

    @SuppressWarnings("deprecation")
    public static void main(String[] args) throws Exception {
        new Finalizer();
        //启用退出JVM时执行Finalizer
        Runtime.runFinalizersOnExit(true);
        MyHook hook1 = new MyHook("Hook1");
        MyHook hook2 = new MyHook("Hook2");
        MyHook hook3 = new MyHook("Hook3");

        //注册关闭钩子
        Runtime.getRuntime().addShutdownHook(hook1);
        Runtime.getRuntime().addShutdownHook(hook2);
        Runtime.getRuntime().addShutdownHook(hook3);

        //移除关闭钩子
        Runtime.getRuntime().removeShutdownHook(hook3);

        //Main线程将在执行这句之后退出
        System.out.println("Main Thread Ends.");
    }

    static class MyHook extends Thread {
        private String name;
        public MyHook (String name) {
            this.name = name;
            setName(name);
        }
        public void run() {
            System.out.println(name + " Ends.");
        }
        //重写Finalizer，将在关闭钩子后调用
        protected void finalize() throws Throwable {
            System.out.println(name + " Finalize.");
        }
    }

    static class Finalizer{
        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("Finalizer Finalize.");
        }
    }
}
打印：
Main Thread Ends.
Hook2 Ends.
Hook1 Ends.
Hook3 Finalize.
Hook2 Finalize.
Hook1 Finalize.
Finalizer Finalize.

 

守护线程

普通线程与守护线程的差异仅在他们退出时发生的操作。当JVM停止时，所有守护线程被抛弃——既不会执行finally代码块，也不会回卷栈，而只是JVM直接退出。所以守护线程不能用来完成应用程序中的生命周期服务，这样可能会造成程序数据的不一致。

 

终结器

         避免使用终结器。会带来同步、性能开销的麻烦。使用finally代码块和close方法替代。

转载笔记请注明出处。

liao_hb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程实践.pdf
09-30
Java并发编程实践.pdf
Java并发编程实践
BXA
05-30 2240
并发编程是指通过设计和实现多线程程序来利用计算机资源和提高程序执行效率的编程方法。它的主要特点是多线程之间的竞争和协作关系。线程安全性是指并发编程中，在多个线程访问共享数据时，对数据的访问不会产生意料之外的后果。实现线程安全性需要从数据的状态变化过程进行分析，并采用相应的线程安全策略。
Java并发编程的实际案例与实践
最新发布
禅与计算机程序设计艺术
01-28 858
1.背景介绍 1. 背景介绍 Java并发编程是一种编程范式，它允许多个线程同时执行多个任务。这种编程方式在现代计算机系统中非常常见，因为它可以充分利用多核处理器的能力，提高程序的执行效率。 Java并发编程的核心概念包括线程、同步、并发集合等。线程是程序中的基本执行单位，同步是保证多个线程之间数据一致性的机制，并发集合是一种特殊的数据结构，它允许多个线程同时操作同一个数据结构。 在实际应...
探究Java并发编程：从基础到实践
grandachn的博客
04-12 103
Java并发编程是Java程序员必须掌握的一项技能。本文介绍了Java中的线程、锁、线程间通信和线程池等概念，并通过代码实例来演示它们的使用。如果你想更深入地了解Java并发编程，推荐阅读Java并发编程实战一书，这本书将会为你深入讲解Java并发编程的各个方面，让你掌握Java并发编程的核心知识。
Java 并发编程实战-创建和执行任务的最佳实践
JavaEdge全是干货的技术号
04-23 2277
若无法通过并行流实现并发，则必须创建并运行自己的任务。运行任务的理想Java 8方法就是CompletableFuture。 Java并发的历史始于非常原始和有问题的机制，并且充满各种尝试的优化。本文将展示一个规范形式，表示创建和运行任务的最简单，最好的方法。 Java初期通过直接创建自己的Thread对象来使用线程，甚至子类化来创建特定“任务线程”对象。手动调用构造函数并自己启动线程。创建所有这些线程的开销变得非常重要，现在不鼓励。Java 5中，添加了类来为你处理线程池。可以将任务创建为单独的类型，然后
java并发编程实践pdf笔记
12-15
Java并发编程实践是Java开发中不可或缺的一个领域，它涉及到如何高效、正确地处理多线程环境中的任务。这本书的读书笔记涵盖了多个关键知识点，旨在帮助读者深入理解Java并发编程的核心概念。 1. **线程和进程的...
java并发编程实践笔记资料.pdf
11-13
Java并发编程实践笔记 Java并发编程实践笔记是一份关于Java并发编程的实践笔记，涵盖了多种关于线程安全、并发编程的实践经验和原则。下面是从笔记中总结的知识点： 1. 保证线程安全的三种方法：不要跨线程访问...
java并发编程实践笔记
03-18
### Java并发编程实践笔记知识点详解 #### 一、保证线程安全的方法 1. **不要跨线程访问共享变量：** 当多个线程共享某个变量时，若其中一个线程修改了该变量，其他线程若没有正确同步，则可能读取到错误的数据。...
JAVA并发编程实践-线程池-学习笔记
07-22
Java并发编程实践中的线程池是一个关键的概念，它在多线程编程中扮演着至关重要的角色，有效地管理和调度线程资源，以提高系统的性能和效率。线程池通过复用已存在的线程来减少线程的创建和销毁开销，避免了频繁的上...
JAVA并发编程实践-线程执行-学习笔记
07-21
总的来说，Java并发编程实践中的任务执行是一个涉及线程调度、线程池管理、任务生命周期控制、结果处理等多个方面的复杂主题。理解和掌握这些概念和技术，能够帮助开发者编写出更加高效、可靠的并发程序。
JAVA并发编程实践
07-31
JAVA并发编程实践 JAVA并发编程实践 JAVA并发编程实践
Java并发编程最佳实例详解系列
热门推荐
loveyouluobin的博客
04-26 1万+
Java并发编程最佳实例详解系列: Java并发编程（一）线程定义、状态和属性 Java并发编程（一）线程定义、状态和属性 线程是指程序在执行过程中，能够执行程序代码的一个执行单元。在java语言中，线程有四种状态：运行 、就绪、挂起和结束。 进程是指一段正在执行的程序。而线程有时也被成为轻量级的进程，他是程序执行的最小单元，一个进程可以拥有多个线程，各个线程之间共享程序的内功空间（代码...
《java并发编程实战》
六种鱼的博客
05-06 5262
（第5章的ConcurrentHashMap部分未完成） 第2章 线程安全性 无状态对象一定是线程安全的，无状态：既不包含任何域，也不包含对其他类中域的引用。 竞态条件（Race Condition）：因不恰当的执行时序而出现不正确的结果（要 想获得正确的结果，取决于事件发生的时序） 原子性：i++不是原子的，包括read-update-write。 对于无状态的类： 增加单个域，可以...
java并发编程实战 java并发编程的艺术 阅读随笔
weixin_30678349的博客
06-03 310
java线程池说明http://www.oschina.net/question/565065_86540 java中断机制http://ifeve.com/java-interrupt-mechanism/ Ask、现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？ join方法 如果一个线程A执行了thread.join()语句，其含义...
【Java多线程编程: 使用Thread类和Runnable接口实现基本的并发编程】
qq_44095715的博客
07-22 174
Java多线程编程是现代软件开发中不可或缺的一部分。在多核CPU和云计算时代，利用多线程并发执行任务可以提高程序的性能和响应能力，从而提升用户体验和系统的可用性。作为一名Java开发人员，了解Java多线程编程的基本概念和最佳实践是非常重要的。本文将介绍Java多线程编程的核心组件Thread类和Runnable接口，并提供一些有用的技巧和经验。Thread类和Runnable接口是Java多线程编程的核心组件。它们都可以用于创建和启动线程，但有一些区别和优缺点。
《Java并发编程实战》【第一部分 基础知识】
lyw4631的博客
01-30 1679
文章目录第1章 简介1.1 并发简史1.2 线程的优势1.2.1 发挥多处理器的强大能力1.2.2 建模的简单性1.2.3 异步事件的简化处理1.2.4 响应更灵敏的用户界面1.3 线程带来的风险1.3.1 安全性问题1.3.2 活跃性问题1.3.3 性能问题1.4 线程无处不在第一部分 基础知识第2章 线程安全性第3章 对象的共享第4章 对象的组合第5章 基础构建模块第二部分 结构化并发应用程序第6章 任务执行第7章 取消与关闭第8章 线程池的使用第9章 图形用户界面应用程序第三部分 活跃性、性能与测试第
Java | 多线程并发编程CountDownLatch实践
Andya_net的博客
11-25 261
在并发编程过程中，如何让多个线程之间协调执行任务，如主线程等所有其他异步线程执行完毕后再继续执行下面的步骤，如何做到？我们可以考虑使用。主要是起到线程之间的同步协调作用，而不是互斥。它可以让一个线程等待其他线程完成任务后，再继续执行自己的任务。是一个同步工具类，主要应用于多线程编程场景中，可以用于控制等待线程的执行，或者说是协调多个线程之间的同步。用好这个工具类，主要关注这个工具类的初始计数值的设置、方法、await()方法即可实现编程。
Java 并发编程实战
传说今天不多说
11-18 591
本文主要编程示例，通过简单示例解析java.util.concurrent并发包下的CopyOnWrite、乐观锁、BlockingQueue、CountDownLatch、CyclicBarrier、Semaphore应用场景
Java并发编程：理解多线程并发问题及其解决方法
weixin_40754174的博客
04-03 4260
java并发编程 多线程 解决方法 示例 锁 并发编程性能优化
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值