AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java并发编程详解

2016-05-19 1924
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

线程的基础知识

关于线程的基础知识，比如线程的创建(Thread,Runnable)，进程和线程的区别，以及线程的sleep、synchronized、wait、interrupt、join、yield等方法就不详细讲解了。有需要的可以参考海子大神的文章。

线程池

创建线程池

在java doc中，并不提倡我们直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来创建线程池：

1
2
3
 
Executors.newCachedThreadPool();        //创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE
Executors.newSingleThreadExecutor();   //创建容量为1的缓冲池
Executors.newFixedThreadPool(int);    //创建固定容量大小的缓冲池

线程池的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
 
package map;

import java.util.Date;
import java.util.concurrent.*;

/**
 * Created by benjamin on 12/24/15.
 */
public class ExecutorsUse {

    public static void main(String[] args) throws InterruptedException {
        fixedThreadPool();
        singleThreadPool();
        newCachedThreadPool();
        scheduledThreadPool();
        singleThreadScheduledPool();
        customThreadPool();
    }

    /**
     * 固定大小的线程池
     */
    private static void fixedThreadPool() throws InterruptedException {
        // 获取线程池最优大小
        int fixNum = Runtime.getRuntime().availableProcessors() + 1;
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(fixNum);
        Thread thread1 = new FixedThread();
        Thread thread2 = new FixedThread();
        Thread thread3 = new FixedThread();
        Thread thread4 = new FixedThread();
        Thread thread5 = new FixedThread();
        fixedThreadPool.execute(thread1);
        fixedThreadPool.execute(thread2);
        fixedThreadPool.execute(thread3);
        fixedThreadPool.execute(thread4);
        fixedThreadPool.execute(thread5);

        // 关闭线程池,不让其他线程加入,但是不终止线程的运行
        fixedThreadPool.shutdown();
        // 会等待线程池的线程都执行结束,才执行下面的语句
        fixedThreadPool.awaitTermination(5, TimeUnit.MINUTES);
        System.out.println("线程执行结束...");

        /**
         * 执行结果:
         * pool-1-thread-1正在执行第: 0次
         * pool-1-thread-4正在执行第: 0次
         * pool-1-thread-3正在执行第: 0次
         * pool-1-thread-5正在执行第: 0次
         * pool-1-thread-2正在执行第: 0次
         * pool-1-thread-5正在执行第: 1次
         * pool-1-thread-3正在执行第: 1次
         * pool-1-thread-3正在执行第: 2次
         * pool-1-thread-4正在执行第: 1次
         * pool-1-thread-4正在执行第: 2次
         * pool-1-thread-1正在执行第: 1次
         * pool-1-thread-5正在执行第: 2次
         * pool-1-thread-2正在执行第: 1次
         * pool-1-thread-2正在执行第: 2次
         * pool-1-thread-1正在执行第: 2次
         * 线程执行结束...
         */
    }

    /**
     * 单任务线程池
     */
    private static void singleThreadPool() throws InterruptedException {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        Thread thread1 = new FixedThread();
        Thread thread2 = new FixedThread();
        Thread thread3 = new FixedThread();
        Thread thread4 = new FixedThread();
        Thread thread5 = new FixedThread();
        singleThreadExecutor.execute(thread1);
        singleThreadExecutor.execute(thread2);
        singleThreadExecutor.execute(thread3);
        singleThreadExecutor.execute(thread4);
        singleThreadExecutor.execute(thread5);

        singleThreadExecutor.shutdown();
        // 关闭线程池,不让其他线程加入,但是不终止线程的运行
        singleThreadExecutor.shutdown();
        // 会等待线程池的线程都执行结束,才执行下面的语句
        singleThreadExecutor.awaitTermination(5, TimeUnit.MINUTES);
        System.out.println("线程执行结束...");

        /**
         * 执行结果:
         * pool-1-thread-1正在执行第: 0次
         * pool-1-thread-1正在执行第: 1次
         * pool-1-thread-1正在执行第: 2次
         * pool-1-thread-1正在执行第: 0次
         * pool-1-thread-1正在执行第: 1次
         * pool-1-thread-1正在执行第: 2次
         * pool-1-thread-1正在执行第: 0次
         * pool-1-thread-1正在执行第: 1次
         * pool-1-thread-1正在执行第: 2次
         * pool-1-thread-1正在执行第: 0次
         * pool-1-thread-1正在执行第: 1次
         * pool-1-thread-1正在执行第: 2次
         * pool-1-thread-1正在执行第: 0次
         * pool-1-thread-1正在执行第: 1次
         * pool-1-thread-1正在执行第: 2次
         * 线程执行结束...
         */
    }

    /**
     * 可变尺寸的线程池
     */
    private static void newCachedThreadPool() throws InterruptedException {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        Thread thread1 = new FixedThread();
        Thread thread2 = new FixedThread();
        Thread thread3 = new FixedThread();
        Thread thread4 = new FixedThread();
        Thread thread5 = new FixedThread();
        newCachedThreadPool.execute(thread1);
        newCachedThreadPool.execute(thread2);
        newCachedThreadPool.execute(thread3);
        newCachedThreadPool.execute(thread4);
        newCachedThreadPool.execute(thread5);

        newCachedThreadPool.shutdown();
        // 关闭线程池,不让其他线程加入,但是不终止线程的运行
        newCachedThreadPool.shutdown();
        // 会等待线程池的线程都执行结束,才执行下面的语句
        newCachedThreadPool.awaitTermination(5, TimeUnit.MINUTES);
        System.out.println("线程执行结束...");

        /**
         * pool-1-thread-1正在执行第: 0次
         * pool-1-thread-5正在执行第: 0次
         * pool-1-thread-4正在执行第: 0次
         * pool-1-thread-3正在执行第: 0次
         * pool-1-thread-2正在执行第: 0次
         * pool-1-thread-2正在执行第: 1次
         * pool-1-thread-3正在执行第: 1次
         * pool-1-thread-4正在执行第: 1次
         * pool-1-thread-4正在执行第: 2次
         * pool-1-thread-5正在执行第: 1次
         * pool-1-thread-5正在执行第: 2次
         * pool-1-thread-1正在执行第: 1次
         * pool-1-thread-3正在执行第: 2次
         * pool-1-thread-2正在执行第: 2次
         * pool-1-thread-1正在执行第: 2次
         * 线程执行结束...
         */
    }

    /**
     * 延迟连接池
     * @throws InterruptedException
     */
    private static void scheduledThreadPool() throws InterruptedException {
        //创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
        Thread thread1 = new FixedThread();
        Thread thread2 = new FixedThread();
        Thread thread3 = new FixedThread();
        Thread thread4 = new FixedThread();
        Thread thread5 = new FixedThread();
        scheduledExecutorService.schedule(thread1, 5, TimeUnit.SECONDS);
        scheduledExecutorService.schedule(thread2, 5, TimeUnit.SECONDS);
        scheduledExecutorService.schedule(thread3, 5, TimeUnit.SECONDS);
        scheduledExecutorService.schedule(thread4, 5, TimeUnit.SECONDS);
        scheduledExecutorService.schedule(thread5, 5, TimeUnit.SECONDS);
        System.out.println("现在开始的时间是: " + new Date());
        // 关闭线程池,不让其他线程加入,但是不终止线程的运行
        scheduledExecutorService.shutdown();
        // 会等待线程池的线程都执行结束,才执行下面的语句
        scheduledExecutorService.awaitTermination(5, TimeUnit.MINUTES);
        System.out.println("线程执行结束...");

        /**
         * 现在开始的时间是: Thu Dec 24 18:05:44 CST 2015
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-4正在执行第: 0次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-1正在执行第: 0次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-2正在执行第: 0次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-2正在执行第: 1次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-1正在执行第: 1次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-3正在执行第: 0次
         * pool-1-thread-4正在执行第: 1次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-1正在执行第: 2次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-2正在执行第: 2次
         * pool-1-thread-5正在执行第: 0次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-4正在执行第: 2次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-5正在执行第: 1次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-5正在执行第: 2次
         * pool-1-thread-3正在执行第: 1次
         * 现在运行的时间是: Thu Dec 24 18:05:49 CST 2015_____
         * pool-1-thread-3正在执行第: 2次
         * 线程执行结束...
         */
    }

    /**
     * 单任务延迟连接池
     */
    private static void singleThreadScheduledPool() {
        ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
        /**
         * 其他都一样,这里就不写了
         */
    }

    /**
     * 自定义连接池
     * 自定义连接池稍微麻烦些，不过通过创建的ThreadPoolExecutor线程池对象，
     * 可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。
     */
    private static void customThreadPool() {
        // 创建等待队列
        BlockingQueue bqueue = new ArrayBlockingQueue(20);
        // 创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 3, 2, TimeUnit.MILLISECONDS, bqueue);
        // ThreadPoolExecutor参数解释
        // corePoolSize - 池中所保存的线程数，包括空闲线程。
        // maximumPoolSize - 池中允许的最大线程数。
        // keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
        // unit - keepAliveTime 参数的时间单位。
        // workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。
        /**
         * 其他都一样,这里就不写了
         */
    }



}

class FixedThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 3; i ++) {
            System.out.println("现在运行的时间是: " + new Date() + "_____");
            System.out.println(Thread.currentThread().getName() + "正在执行第: " + i + "次");
        }
    }
}

在工作中如何设置线程池的大小呢？

设置线程池的大小

线程池的理想大小取决于被提交任务的类型以及所部署系统的特性。在代码中通常不会固定线程池的大小，而应该通过某种配置机制来提供，或者根据Runtime.availableProcessors来动态计算。
幸运的是，要设置线程池的大小也并不困难，只需要避免“过大”和“过小”这两种极端情况。如果线程池过大，那么大量的线程将在相对很少的CPU和内存资源上发生竞争，这不仅会导致更高的内存使用量，而且还可能耗尽资源。如果线程池过小，那么将导致许多空间的处理器无法执行工作，从而降低吞吐率。
要想正确地设置线程池的大小，必须分析计算环境、资源预算和任务的特性。在部署的系统中有多少个CPU？多大的内存？任务是计算密集型、I/O密集型还是二者皆可？它们是否需要像JDBC连接这样的稀缺资源？如果需要执行不同类别的任务，并且它们之间的行为相差很大，那么应该考虑使用多个线程池，从而使每个线程池可以根据各自的工作负载来调整。
对于计算密集型的任务，在拥有Ncpu个处理器的系统上，当线程池的大小为 Ncpu+1 时，通常能实现最优的利用率。
线程池的最优大小等于：

Nthreads = Ncpu * Ucpu * (1+W/C)

给定下列定义：

Ncpu是CPU的数目，一般可以通过这个公式获取
int N_CPUS = Runtime.getRuntime().availableProcessors()

Ucpu：CPU的利用率，范围为 0<=Ucpu<=1
W/C：是等待时间和计算时间的比值

一般需要根据任务的类型来配置线程池大小：

　　如果是CPU密集型任务，就需要尽量压榨CPU，参考值可以设为 NCPU+1

　　如果是IO密集型任务，参考值可以设置为2*NCPU

　　当然，这只是一个参考值，具体的设置还需要根据实际情况进行调整，比如可以先将线程池大小设置为参考值，再观察任务运行情况和系统负载、资源利用率来进行适当调整。

Callable和Future以及FutureTask的实例应用


　　
    有的时候我们的应用需要拿到线程执行完毕后的返回值，这个时候就需要用到Callable和Future以及FutureTask了。下面是一个实例，copy就可以运行，也可以看实例有详细注释说明。
　　 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
package map;

import java.util.Random;
import java.util.concurrent.*;

/**
 * Created by benjamin on 12/25/15.
 */
public class CallableAndFuture {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        testCallableAndFuture();
        testCallableAndFuture2();
        testCallableAndFuture3();
        testCallableAndFutureTask();
    }

    /**
     * 一个简单地Callable 和 future的使用简介
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private static void testCallableAndFuture() throws ExecutionException, InterruptedException {
        Callable<Integer> call = new Callable<Integer>() {
            public Integer call() throws Exception {
                Thread.sleep(1000);
                return new Random().nextInt(100);
            }
        };

        FutureTask<Integer> future = new FutureTask<Integer>(call);
        new Thread(future).start();
        System.out.println("执行开始");
        // 一直等到拿到值才继续往下走
        System.out.println(future.get());
        System.out.println("执行结束");

        /**
         * result
         * 执行开始
           24
           执行结束
         */
    }

    /**
     * 在线程池中使用Callable来执行对应的任务.
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private static void testCallableAndFuture2() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<Integer> future = executorService.submit(new Callable<Integer>() {
            public Integer call() throws Exception {
                Thread.sleep(1000);
                return new Random().nextInt(100);
            }
        });
        System.out.println("线程开始");
        System.out.println(future.get());
        System.out.println("线程结束");

        /**
         * 执行结果和上面一样
         */
    }

    /**
     * 执行多个callable 和 future任务,并且得到返回值
     * @throws InterruptedException
     * @throws ExecutionException
     */
    private static void testCallableAndFuture3() throws InterruptedException, ExecutionException {
        ExecutorService threadPool = Executors.newCachedThreadPool();
        CompletionService<Integer> cs = new ExecutorCompletionService<Integer>(threadPool);
        for (int i = 1; i < 5; i++) {
            final int taskID = i;
            cs.submit(new Callable<Integer>() {
                public Integer call() throws Exception {
                    System.out.println("子线程在进行计算");
                    Thread.sleep(taskID * 1000);
                    return taskID;
                }
            });
        }
        System.out.println("线程开始");
        for (int i = 1; i < 5; i++) {
            System.out.println(cs.take().get());
        }
        System.out.println("线程结束");

        /**
         * 执行的结果
         * 子线程在进行计算
           子线程在进行计算
           线程开始
           子线程在进行计算
           子线程在进行计算
           1 (每隔一秒输出下一个数,这表明get()是有一个值输出就立刻返回再继续等待下面的输出,最后全部输出完成向下执行)
           2
           3
           4
           线程结束
         */
    }

    /**
     * futureTask的使用
     * FutureTask类实现了RunnableFuture接口,RunnableFuture继承了Runnable接口和Future接口
     * 所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
     */
    private static void testCallableAndFutureTask() {
        ExecutorService threadPool = Executors.newCachedThreadPool();
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        threadPool.submit(futureTask);
        threadPool.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("主线程在执行任务");

        try {
            System.out.println("task执行结果: " + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务执行完毕");
    }
}

/**
 * 任务task
 */
class Task implements Callable<Integer> {

    public Integer call() throws Exception {
        System.out.println("子线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i < 100; i++) sum += i;
        return sum;
    }
}

参考文章： 海子大神

文章标签：
Java
关键词：
Java编程
Java并发编程
benjaminwhx
目录
相关文章
mrq4nk6ni2neg
|
21天前
|
设计模式 安全 Java
Java编程中的单例模式：理解与实践
【10月更文挑战第31天】在Java的世界里，单例模式是一种优雅的解决方案，它确保一个类只有一个实例，并提供一个全局访问点。本文将深入探讨单例模式的实现方式、使用场景及其优缺点，同时提供代码示例以加深理解。无论你是Java新手还是有经验的开发者，掌握单例模式都将是你技能库中的宝贵财富。
mrq4nk6ni2neg
29 2
叫个什么名字
|
10天前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区，如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等，并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比，直观展示了正确与错误的实现方式，旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
叫个什么名字
30 5
艾利克斯冰
|
16天前
|
JSON Java Apache
非常实用的Http应用框架，杜绝Java Http 接口对接繁琐编程
UniHttp 是一个声明式的 HTTP 接口对接框架，帮助开发者快速对接第三方 HTTP 接口。通过 @HttpApi 注解定义接口，使用 @GetHttpInterface 和 @PostHttpInterface 等注解配置请求方法和参数。支持自定义代理逻辑、全局请求参数、错误处理和连接池配置，提高代码的内聚性和可读性。
艾利克斯冰
66 3
yuanzhengme
|
23天前
|
Java API Apache
Java编程如何读取Word文档里的Excel表格，并在保存文本内容时保留表格的样式？
【10月更文挑战第29天】Java编程如何读取Word文档里的Excel表格，并在保存文本内容时保留表格的样式？
yuanzhengme
97 5
1941623231718325
|
18天前
|
安全 Java 编译器
JDK 10中的局部变量类型推断：Java编程的简化与革新
JDK 10引入的局部变量类型推断通过`var`关键字简化了代码编写，提高了可读性。编译器根据初始化表达式自动推断变量类型，减少了冗长的类型声明。虽然带来了诸多优点，但也有一些限制，如只能用于局部变量声明，并需立即初始化。这一特性使Java更接近动态类型语言，增强了灵活性和易用性。
1941623231718325
95 53
游客5fdji2pvmf8888
|
9天前
|
Java 开发者
Java多线程编程的艺术与实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的技术文档，本文以实战为导向，通过生动的实例和详尽的代码解析，引领读者领略多线程编程的魅力，掌握其在提升应用性能、优化资源利用方面的关键作用。无论你是Java初学者还是有一定经验的开发者，本文都将为你打开多线程编程的新视角。 ####
游客5fdji2pvmf8888
31 6
游客762btuqu5wybw666
|
8天前
|
存储 安全 Java
Java多线程编程中的并发容器：深入解析与实战应用####
在本文中，我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构，并发容器专为多线程场景设计，确保数据访问的线程安全性和高效性。我们将从基础概念出发，逐步深入到`java.util.concurrent`包下的核心并发容器实现，如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等，通过实例代码演示其使用方法，并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者，本文都将为你提供有价值的见解与实践指导。 --- ####
游客762btuqu5wybw666
20 3
叫个什么名字
|
11天前
|
安全 Java 开发者
Java多线程编程中的常见问题与解决方案
本文深入探讨了Java多线程编程中常见的问题，包括线程安全问题、死锁、竞态条件等，并提供了相应的解决策略。文章首先介绍了多线程的基础知识，随后详细分析了每个问题的产生原因和典型场景，最后提出了实用的解决方案，旨在帮助开发者提高多线程程序的稳定性和性能。
叫个什么名字
44 1
叫个什么名字
|
17天前
|
存储 安全 Java
Java多线程编程的艺术：从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式，旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战，随后详细介绍了Java中创建和管理线程的两种主要方式：继承Thread类与实现Runnable接口。通过实例代码，本文展示了如何正确启动、运行及同步线程，以及如何处理线程间的通信与协作问题。最后，文章总结了多线程编程的最佳实践，为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
叫个什么名字
56 5
ShaFaChuang-36210
|
14天前
|
监控 安全 Java
Java中的多线程编程：从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式，本文将以一个简短的代码示例作为开篇，直接展示多线程的魅力，随后再详细解析其背后的原理与实现方式，旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例：创建两个线程，分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
ShaFaChuang-36210
33 1

热门文章

最新文章

  • 1
    Java发送Http请求（HttpClient）
  • 2
    【Java】留下没有基础眼泪的面试题
  • 3
    JVM - 一篇带你读懂 Java GC 日志（附 GC 耗时讲解）
  • 4
    JAVA并发处理经验(一)多线程总结
  • 5
    使用 Java 进行物联网（IoT）应用开发
  • 6
    java: 程序包javax.servlet不存在、 java: 程序包javax.servlet.http不存在 java: 程序包javax.servlet.annotation不存在
  • 7
    Java控制内存的功力
  • 8
    对象共享：Java并发环境中的烦心事
  • 9
    Java || 线程 || 大一新生 || 一篇synchronized锁的知识点总结
  • 10
    java-subString方法易导致内存溢出
  • 1
    Java对象转换为JSON字符串
    75
  • 2
    怎么用Java 把多个音频拼接成一个？
    136
  • 3
    Java中的异常处理：从基础到高级
    37
  • 4
    Java 内存管理与垃圾回收机制深度解析
    62
  • 5
    Java 内存模型深度解析
    49
  • 6
    《手把手教你》系列基础篇（九十七）-java+ selenium自动化测试-框架设计篇-Selenium方法的二次封装和页面基类（详解教程）
    115
  • 7
    java代码实现清空浏览器缓存
    131
  • 8
    day17：Java零基础 - 基本类型转换
    32
  • 9
    实时计算 Flink版操作报错合集之使用kafka connector时，报错：java.lang.ClassNotFoundException，是什么原因
    363
  • 10
    实时计算 Flink版操作报错合集之拉取全量数据时，如何解决Checkpoint失败并且报错为 "java.lang.OutOfMemoryError: Java heap space"
    148

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    无影云桌面