爪哇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博客