爪哇2博客
关
爪哇2博客

如何使用Java中的线程打印偶数和奇数

在这篇文章中，我们将看到如何使用 线程数 在Java中。

也可以看看： 如何在Java中使用3个线程打印序列

问题

您有两个线程。您需要使用一个线程打印奇数，而使用另一线程打印偶数。您需要以自然顺序打印，最大为MAX。
例如：
如果MAX为10，则需要打印：

1 2 3 4 5 6 7 8 9 10

所以1 3 5 7 9将由奇数线打印
2 4 6 8 10将用偶数线打印。

进一步阅读

爪哇中的wait，notify和notifyAll方法以及示例

爪哇中的wait，notify和notifyAll方法以及示例

您可能已经注意到Object类具有三个最终方法，分别称为wait，notify和notifyAll。这些方法用于…
阅读更多
在Java中使用3个线程打印序列

在Java中使用3个线程打印序列

在这篇文章中，我们将看到如何在Java中使用3个线程来打印序列，这类似于打印奇偶数…
阅读更多

解决方案1

我们将使用 等待并通知 解决如何使用Java中的线程打印偶数和奇数。

  • 使用一个名为boolean的变量 奇。如果要打印奇数，它’s的值应为true，反之亦然。
  • 创造 two methods printOdd() and printEven(), one 将 print 奇 数s and other 将 print even 数s.
  • 创造 two 线程数, t2 for 奇 and t1 for even.
  • t1 将 call printEven() method and t2 将 call printOdd() method simultaneously.
  • If 布尔值 奇 is 真正 in printEven() method, t1 将 等待.
  • If 布尔值 奇 is 假 in printOdd() method, t2 将 等待.

使用Java中的线程打印偶数和奇数

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
 
包 组织.Arpit.爪哇2blog;
 
上市 类 OddEvenPrintMain {
 
    布尔值 奇;
    整型 计数 = 1;
    整型 最大 = 20;
 
    上市 虚空 printOdd() {
        已同步 (这个) {
            而 (计数 < 最大) {
                系统.出.打印(“检查奇数循环”);
 
                而 (!奇) {
                    尝试 {
                        系统.出.打印(“奇怪的等待：” + 计数);
                        等待();
                        系统.出.打印(“通知单：” + 计数);
                    } 抓住 (InterruptedException e) {
                        // TODO自动生成的catch块
                        e.printStackTrace();
                    }
                }
                系统.出.打印(“奇数线程：” + 计数);
                计数++;
                奇 = 假;
                通知();
            }
        }
    }
 
    上市 虚空 printEven() {
 
        尝试 {
            线.睡觉(1000);
        } 抓住 (InterruptedException e1) {
            e1.printStackTrace();
        }
        已同步 (这个) {
            而 (计数 < 最大) {
                系统.出.打印(“检查偶数循环”);
 
                而 (奇) {
                    尝试 {
                        系统.出.打印(“甚至在等待：” + 计数);
                        等待();
                        系统.出.打印(“甚至通知：” + 计数);
                    } 抓住 (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                系统.出.打印(“甚至线程：” + 计数);
                计数++;
                奇 = 真正;
                通知();
 
            }
        }
    }
 
    上市 静态的 虚空 主要(串[] args) {
 
        OddEvenPrintMain ep = 新 OddEvenPrintMain();
        ep.奇 = 真正;
        线 t1 = 新 线(新 可运行() {
 
            @覆写
            上市 虚空 跑() {
                ep.printEven();
 
            }
        });
        线 t2 = 新 线(新 可运行() {
 
            @覆写
            上市 虚空 跑() {
                ep.printOdd();
 
            }
        });
 
        t1.开始();
        t2.开始();
 
        尝试 {
            t1.加入();
            t2.加入();
        } 抓住 (InterruptedException e) {
            e.printStackTrace();
        }
 
    }
}
 

：

检查奇数循环
奇数线程：1
检查奇数循环
等待奇数：2
检查偶数循环
偶数：2
检查偶数循环
甚至等待：3
通知单数：3
奇数线程：3
检查奇数循环
等待奇数：4
甚至通知：4
偶数：4
检查偶数循环
甚至等待：5
通知单数：5
奇数线程：5
检查奇数循环
等待奇数：6
甚至通知：6
偶数：6
检查偶数循环
甚至等待：7
通知单数：7
奇数线程：7
检查奇数循环
等待奇数：8
甚至通知：8
偶数：8
检查偶数循环
甚至等待：9
通知单数：9
奇数线程：9
检查奇数循环
等待奇数：10
甚至通知：10
偶数：10
检查偶数循环
甚至等待：11
通报奇数：11
奇数线程：11
检查奇数循环
等待奇数：12
甚至通知：12
偶数：12
检查偶数循环
甚至等待：13
通报奇数：13
奇数线程：13
检查奇数循环
等待奇数：14
甚至通知：14
偶数：14
检查偶数循环
甚至等待：15
通报奇数：15
奇数线程：15
检查奇数循环
等待奇数：16
甚至通知：16
偶数：16
检查偶数循环
甚至等待：17
通报奇数：17
奇数线程：17
检查奇数循环
等待奇数：18
甚至通知：18
偶数：18
检查偶数循环
甚至等待：19
通报奇数：19
奇数线程：19
甚至通知：20
偶数：20

如果您观察到输出，则应该能够理解上述程序。

让我尝试解释前几行：
检查奇数循环： t2 Checks for 而 condition in printOdd() method
奇数线程：1： t2 打印计数，将其递增一并进行 奇=false
检查奇数循环： Checks for 而 condition in printOdd() method
等待奇数：2： Since 奇=false  now, t2 将 等待 and releases the 锁
检查偶数循环： t1 checks for 而 condition in printEven() method
偶数线程：2： t1 prints the 计数,increment it by one and make 奇=true
检查偶数循环： t1 checks for 而 condition in printEven() method
甚至等待：3： Since 奇=true now, t1 将 等待 and releases the 锁
通报奇数：3： Since we have called 通知() when we were printing Even thread 2, it 将 通知 t2.

所有其他步骤将继续。

解决方案2：使用余数

您可以在这里使用剩余的概念。

  • If 数%2==1 then Odd 将 print the 数 and increment it else 将 go in the 等待 state.
  • If 数%2==0 then Even 将 print the 数 and increment it else 将 go in the 等待 state.

让’借助示例进行检查。

创造 a 类 命名 奇数甚至可运行 and 实行 可运行 接口。

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
 
创造 a 类 命名 [[码]]czoxNTpcIk9kZEV2ZW5SdW5uYWJsZVwiO3tbJiomXX0=[[/码]]. 它 将 实行 可运行 接口.
 
上市 类 奇数甚至可运行 实施 可运行{
 
    上市 整型 PRINT_NUMBERS_UPTO=10;
    静态的 整型  数=1;
    整型 余;
    静态的 目的 锁=新 目的();
 
    奇数甚至可运行(整型 余)
    {
        这个.余=余;
    }
 
    @覆写
    上市 虚空 跑() {
        而 (数 < PRINT_NUMBERS_UPTO) {
            已同步 (锁) {
                而 (数 % 2 ！= 余) { //等待除余数以外的数字
                    尝试 {
                        锁.等待();
                    } 抓住 (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                系统.出.打印(线.currentThread().getName() + ” + 数);
                数++;
                锁.通知All();
            }
        }
    }
}
 

创建名为的主类"PrintOddEvenMain"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
上市 类 PrintOddEvenMain {
    上市 静态的 虚空 主要(串[] args) {
 
        奇数甚至可运行 奇怪的=新 奇数甚至可运行(1);
        奇数甚至可运行 即使可运行=新 奇数甚至可运行(0);
 
        线 t1=新 线(奇怪的,“奇”);
        线 t2=新 线(即使可运行,“甚至”);
 
        t1.开始();
        t2.开始();
 
    }
}
 

当您在程序上方运行时，将获得以下输出

Odd 1
Even 2
Odd 3
Even 4
Odd 5
Even 6
Odd 7
Even 8
Odd 9
偶十

这就是使用java中的线程打印偶数和奇数的全部内容。如果解释不清楚，请发表评论。

您可能还喜欢：


导入联系人

您可能还喜欢：

分享这个

作者

关注作者

相关文章

  • 获取Java中的线程ID
    9月30日

    获取Java中的线程ID

    在本文中，我们将学习获取Java中正在运行的线程的线程ID。 Id是在线程创建时生成的唯一正数。该ID在线程的生存期内保持不变。线程终止时，其ID可用于引用另一个线程，但是[…]

  • 爪哇中的ArrayBlockingQueue
    9月19日

    爪哇中的ArrayBlockingQueue

    在本文中，我们将了解Java并发队列BlockingQueue。然后我们将深入其中’其中之一的实现ArrayBlockingQueue。什么是BlockingQueue 阻塞队列接口是在Java 5中并发API下引入的，它表示一个线程安全的队列，可以在其中添加和删除元素。我们可以有 […]

  • 将Java程序延迟几秒钟
    12月11日

    将Java程序延迟几秒钟

    在这篇文章中，我们将看到如何将Java程序延迟几秒钟。在很多情况下，我们需要等待其他任务完成，因此我们需要延迟Java程序。有多种方法可以延迟Java程序的执行。使用Thread.sleep 睡觉方法会使当前线程暂停[…]

  • 爪哇中的wait（），notify（）和notifyAll（）
    10月22日

    为什么在对象类中使用wait（），notify（）和notifyAll（）方法

    在这篇文章中，我们将看到为什么wait（），notify（）和notifyAll（）方法在对象类中而不在线程类中。这是最常问到的Java多线程面试问题之一。您可能知道wait（），notify（）和notifyAll（）方法在Object类中，您知道相同的原因吗？让’s […]

  • 爪哇中的自定义BlockingQueue
    10月16日

    爪哇中的自定义BlockingQueue实现

    在本文中，我们将看到如何创建自己的自定义BlockingQueue。这是最常被问到的Java面试问题之一。您需要实现自己的BlockingQueue。这个问题有助于面试官对多线程概念有所了解。这是BlockingQueue的简单实现。我们将使用数组将元素存储在[…]

  • 爪哇中Runnable和Callable之间的区别
    12月16日

    爪哇中Runnable和Callable之间的区别

    可运行和Callable接口都在多线程环境中使用。Callable在java.util.concurrent.Callable包中可用，而Runnable在java.lang.Thread中可用。 爪哇中Runnable和Callable接口之间的区别Runnable在Java 1.0版本中引入，而Callable是Runnable的扩展版本，并在Java 1.5中引入，以解决Runnable的局限性。可运行[…]

Comments

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


让’s be Friends

©2020 爪哇2博客