Java 线程的交替运行范例

最新推荐文章于 2024-05-14 07:00:00 发布
最新推荐文章于 2024-05-14 07:00:00 发布
阅读量352 收藏
点赞数
分类专栏： Java多线程 文章标签： 线程交替运行 线程交替工作 线程交替工作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengzizhi/article/details/85064676
版权

范例1：两个线程交替打印1-100之间的整数

package com.contoso;

public class MultiThreadPrinter {

    public static int intValue = 1;

    public static void main(String[] args) {

        Printer printer = new Printer();
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (intValue <= 100) {
                        printer.print(intValue++);
                    }
                }
            }).start();
        }

    }

    static class Printer {

        public void print(int intValue) {
            synchronized (this) {
                notify(); // 唤醒另一个线程
                System.out.println(Thread.currentThread().getName() + " " + intValue);
                try {
                    // 休眠200毫秒让打印效果更具备观赏性
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                 try {
                    wait(); // 释放掉锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
run:
Thread-0 1
Thread-1 2
Thread-0 3
Thread-1 4
Thread-0 5
Thread-1 6
Thread-0 7
Thread-1 8
Thread-0 9
Thread-1 10
Thread-0 11
Thread-1 12
Thread-0 13
Thread-1 14
Thread-0 15
Thread-1 16
Thread-0 17
Thread-1 18
Thread-0 19
Thread-1 20
Thread-0 21
Thread-1 22
Thread-0 23
Thread-1 24
Thread-0 25
Thread-1 26
Thread-0 27
Thread-1 28
Thread-0 29
Thread-1 30
Thread-0 31
Thread-1 32
Thread-0 33
Thread-1 34
Thread-0 35
Thread-1 36
Thread-0 37
Thread-1 38
Thread-0 39
Thread-1 40
Thread-0 41
Thread-1 42
Thread-0 43
Thread-1 44
Thread-0 45
Thread-1 46
Thread-0 47
Thread-1 48
Thread-0 49
Thread-1 50
Thread-0 51
Thread-1 52
Thread-0 53
Thread-1 54
Thread-0 55
Thread-1 56
Thread-0 57
Thread-1 58
Thread-0 59
Thread-1 60
Thread-0 61
Thread-1 62
Thread-0 63
Thread-1 64
Thread-0 65
Thread-1 66
Thread-0 67
Thread-1 68
Thread-0 69
Thread-1 70
Thread-0 71
Thread-1 72
Thread-0 73
Thread-1 74
Thread-0 75
Thread-1 76
Thread-0 77
Thread-1 78
Thread-0 79
Thread-1 80
Thread-0 81
Thread-1 82
Thread-0 83
Thread-1 84
Thread-0 85
Thread-1 86
Thread-0 87
Thread-1 88
Thread-0 89
Thread-1 90
Thread-0 91
Thread-1 92
Thread-0 93
Thread-1 94
Thread-0 95
Thread-1 96
Thread-0 97
Thread-1 98
Thread-0 99
Thread-1 100

范例2：两个线程交替打印1-100之间的整数,一个线程打印奇数，另外一个线程打印偶数

package com.contoso;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MultiThreadPrinter {

    private static Lock lock = new ReentrantLock();
    private static Condition condition1 = lock.newCondition();
    private static Condition condition2 = lock.newCondition();

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            for (int i = 1; i <= 99; i += 2) {
                lock.lock();
                try {
                    condition2.signal();
                    System.out.println(Thread.currentThread().getName() + " " + i);
                    condition1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 2; i <= 100; i += 2) {
                lock.lock();
                try {
                    condition1.signal();
                    System.out.println(Thread.currentThread().getName() + " " + i);
                    condition2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }

            }
        });

        t1.start();
        t2.start();
    }
}
run:
Thread-0 1
Thread-1 2
Thread-0 3
Thread-1 4
Thread-0 5
Thread-1 6
Thread-0 7
Thread-1 8
Thread-0 9
Thread-1 10
Thread-0 11
Thread-1 12
Thread-0 13
Thread-1 14
Thread-0 15
Thread-1 16
Thread-0 17
Thread-1 18
Thread-0 19
Thread-1 20
Thread-0 21
Thread-1 22
Thread-0 23
Thread-1 24
Thread-0 25
Thread-1 26
Thread-0 27
Thread-1 28
Thread-0 29
Thread-1 30
Thread-0 31
Thread-1 32
Thread-0 33
Thread-1 34
Thread-0 35
Thread-1 36
Thread-0 37
Thread-1 38
Thread-0 39
Thread-1 40
Thread-0 41
Thread-1 42
Thread-0 43
Thread-1 44
Thread-0 45
Thread-1 46
Thread-0 47
Thread-1 48
Thread-0 49
Thread-1 50
Thread-0 51
Thread-1 52
Thread-0 53
Thread-1 54
Thread-0 55
Thread-1 56
Thread-0 57
Thread-1 58
Thread-0 59
Thread-1 60
Thread-0 61
Thread-1 62
Thread-0 63
Thread-1 64
Thread-0 65
Thread-1 66
Thread-0 67
Thread-1 68
Thread-0 69
Thread-1 70
Thread-0 71
Thread-1 72
Thread-0 73
Thread-1 74
Thread-0 75
Thread-1 76
Thread-0 77
Thread-1 78
Thread-0 79
Thread-1 80
Thread-0 81
Thread-1 82
Thread-0 83
Thread-1 84
Thread-0 85
Thread-1 86
Thread-0 87
Thread-1 88
Thread-0 89
Thread-1 90
Thread-0 91
Thread-1 92
Thread-0 93
Thread-1 94
Thread-0 95
Thread-1 96
Thread-0 97
Thread-1 98
Thread-0 99
Thread-1 100

范例3：两个线程交替打印1-100之间的整数,一个线程打印奇数，另外一个线程打印偶数

package com.contoso;

public class MultiThreadPrinter {

    private static Object obj = new Object();

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            for (int i = 1; i <= 99; i += 2) {
                synchronized (obj) {
                        System.out.println(Thread.currentThread().getName() + " " + i);
                        try {
                            Thread.sleep(200);
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        obj.notify();                  
                }
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 2; i <= 100; i += 2) {
                synchronized (obj) {
                        System.out.println(Thread.currentThread().getName() + " " + i);
                        obj.notify();
                        try {
                            Thread.sleep(200);
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                }
            }
        });

        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}
run:
Thread-0 1
Thread-1 2
Thread-0 3
Thread-1 4
Thread-0 5
Thread-1 6
Thread-0 7
Thread-1 8
Thread-0 9
Thread-1 10
Thread-0 11
Thread-1 12
Thread-0 13
Thread-1 14
Thread-0 15
Thread-1 16
Thread-0 17
Thread-1 18
Thread-0 19
Thread-1 20
Thread-0 21
Thread-1 22
Thread-0 23
Thread-1 24
Thread-0 25
Thread-1 26
Thread-0 27
Thread-1 28
Thread-0 29
Thread-1 30
Thread-0 31
Thread-1 32
Thread-0 33
Thread-1 34
Thread-0 35
Thread-1 36
Thread-0 37
Thread-1 38
Thread-0 39
Thread-1 40
Thread-0 41
Thread-1 42
Thread-0 43
Thread-1 44
Thread-0 45
Thread-1 46
Thread-0 47
Thread-1 48
Thread-0 49
Thread-1 50
Thread-0 51
Thread-1 52
Thread-0 53
Thread-1 54
Thread-0 55
Thread-1 56
Thread-0 57
Thread-1 58
Thread-0 59
Thread-1 60
Thread-0 61
Thread-1 62
Thread-0 63
Thread-1 64
Thread-0 65
Thread-1 66
Thread-0 67
Thread-1 68
Thread-0 69
Thread-1 70
Thread-0 71
Thread-1 72
Thread-0 73
Thread-1 74
Thread-0 75
Thread-1 76
Thread-0 77
Thread-1 78
Thread-0 79
Thread-1 80
Thread-0 81
Thread-1 82
Thread-0 83
Thread-1 84
Thread-0 85
Thread-1 86
Thread-0 87
Thread-1 88
Thread-0 89
Thread-1 90
Thread-0 91
Thread-1 92
Thread-0 93
Thread-1 94
Thread-0 95
Thread-1 96
Thread-0 97
Thread-1 98
Thread-0 99
Thread-1 100
BUILD SUCCESSFUL (total time: 20 seconds)

范例4：3个线程交替打印1-100之间的整数

package com.contoso;

public class MultiThreadPrinter {

    private static volatile int i = 1;
    private static volatile int flag = 0;

    public static void main(String[] args) throws InterruptedException {
        new Thread(new Printer1()).start();
        new Thread(new Printer2()).start();
        new Thread(new Printer3()).start();
    }

    static class Printer1 implements Runnable {

        public void run() {
            while (i <= 100) {
                if (flag == 0) {
                    System.out.println(Thread.currentThread().getName() + " " + i);
                    i++;
                    flag = 1;
                }
            }
        }

    }

    static class Printer2 implements Runnable {

        public void run() {
            while (i <= 100) {
                if (flag == 1) {
                    System.out.println(Thread.currentThread().getName() + " " + i);
                    i++;
                    flag = 2;
                }
            }
        }

    }

    static class Printer3 implements Runnable {
        
        public void run() {
            while (i <= 100) {
                if (flag == 2) {
                    System.out.println(Thread.currentThread().getName() + " " + i);
                    i++;
                    flag = 0;
                }
            }
        }

    }

}
run:
Thread-0 1
Thread-1 2
Thread-2 3
Thread-0 4
Thread-1 5
Thread-2 6
Thread-0 7
Thread-1 8
Thread-2 9
Thread-0 10
Thread-1 11
Thread-2 12
Thread-0 13
Thread-1 14
Thread-2 15
Thread-0 16
Thread-1 17
Thread-2 18
Thread-0 19
Thread-1 20
Thread-2 21
Thread-0 22
Thread-1 23
Thread-2 24
Thread-0 25
Thread-1 26
Thread-2 27
Thread-0 28
Thread-1 29
Thread-2 30
Thread-0 31
Thread-1 32
Thread-2 33
Thread-0 34
Thread-1 35
Thread-2 36
Thread-0 37
Thread-1 38
Thread-2 39
Thread-0 40
Thread-1 41
Thread-2 42
Thread-0 43
Thread-1 44
Thread-2 45
Thread-0 46
Thread-1 47
Thread-2 48
Thread-0 49
Thread-1 50
Thread-2 51
Thread-0 52
Thread-1 53
Thread-2 54
Thread-0 55
Thread-1 56
Thread-2 57
Thread-0 58
Thread-1 59
Thread-2 60
Thread-0 61
Thread-1 62
Thread-2 63
Thread-0 64
Thread-1 65
Thread-2 66
Thread-0 67
Thread-1 68
Thread-2 69
Thread-0 70
Thread-1 71
Thread-2 72
Thread-0 73
Thread-1 74
Thread-2 75
Thread-0 76
Thread-1 77
Thread-2 78
Thread-0 79
Thread-1 80
Thread-2 81
Thread-0 82
Thread-1 83
Thread-2 84
Thread-0 85
Thread-1 86
Thread-2 87
Thread-0 88
Thread-1 89
Thread-2 90
Thread-0 91
Thread-1 92
Thread-2 93
Thread-0 94
Thread-1 95
Thread-2 96
Thread-0 97
Thread-1 98
Thread-2 99
Thread-0 100
BUILD SUCCESSFUL (total time: 0 seconds)

范例5：先让子线程执行3次，然后让主线程执行5次，如此往复10次

package com.contoso;
/**
 * 
 * 先让子线程执行3次，然后让主线程执行5次，如此往复10次
 */
public class MainApp {

    public static void main(String[] args) {

        Printer printer = new Printer();
        new Thread(new Runnable() {
            public void run() {
                // 子线程执行10次
                for (int i = 1; i <= 10; i++) {
                    printer.child(i);
                }
            }
        }
        ).start();
        // 主线程执行10次
        for (int i = 1; i <= 10; i++) {
            printer.main(i);
        }
        
    }
}

class Printer {

    private boolean isRunning = true;

    public synchronized void child(int i) {
        while (!isRunning) {
            try {
                this.wait();   //让子线程睡眠等待，并释放锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int j = 1; j <= 3; j++) {
            System.out.println(Thread.currentThread().getName() + " " + j + " loop of " + i);
        }
        isRunning = false;
        this.notify(); // 唤醒主线程去执行
    }

    public synchronized void main(int i) {
        while (isRunning) {
            try {
                this.wait();  //让主线程睡眠等待，并释放锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int j = 1; j <= 5; j++) {
            System.out.println(Thread.currentThread().getName() + " " + j + " loop of  " + i);
        }
        isRunning = true;
        this.notify(); // 唤醒子线程去执行
    }
}
run:
Thread-0 1 loop of 1
Thread-0 2 loop of 1
Thread-0 3 loop of 1
main 1 loop of  1
main 2 loop of  1
main 3 loop of  1
main 4 loop of  1
main 5 loop of  1
Thread-0 1 loop of 2
Thread-0 2 loop of 2
Thread-0 3 loop of 2
main 1 loop of  2
main 2 loop of  2
main 3 loop of  2
main 4 loop of  2
main 5 loop of  2
Thread-0 1 loop of 3
Thread-0 2 loop of 3
Thread-0 3 loop of 3
main 1 loop of  3
main 2 loop of  3
main 3 loop of  3
main 4 loop of  3
main 5 loop of  3
Thread-0 1 loop of 4
Thread-0 2 loop of 4
Thread-0 3 loop of 4
main 1 loop of  4
main 2 loop of  4
main 3 loop of  4
main 4 loop of  4
main 5 loop of  4
Thread-0 1 loop of 5
Thread-0 2 loop of 5
Thread-0 3 loop of 5
main 1 loop of  5
main 2 loop of  5
main 3 loop of  5
main 4 loop of  5
main 5 loop of  5
Thread-0 1 loop of 6
Thread-0 2 loop of 6
Thread-0 3 loop of 6
main 1 loop of  6
main 2 loop of  6
main 3 loop of  6
main 4 loop of  6
main 5 loop of  6
Thread-0 1 loop of 7
Thread-0 2 loop of 7
Thread-0 3 loop of 7
main 1 loop of  7
main 2 loop of  7
main 3 loop of  7
main 4 loop of  7
main 5 loop of  7
Thread-0 1 loop of 8
Thread-0 2 loop of 8
Thread-0 3 loop of 8
main 1 loop of  8
main 2 loop of  8
main 3 loop of  8
main 4 loop of  8
main 5 loop of  8
Thread-0 1 loop of 9
Thread-0 2 loop of 9
Thread-0 3 loop of 9
main 1 loop of  9
main 2 loop of  9
main 3 loop of  9
main 4 loop of  9
main 5 loop of  9
Thread-0 1 loop of 10
Thread-0 2 loop of 10
Thread-0 3 loop of 10
main 1 loop of  10
main 2 loop of  10
main 3 loop of  10
main 4 loop of  10
main 5 loop of  10
BUILD SUCCESSFUL (total time: 0 seconds)

 

zhengzizhi
关注
专栏目录
多线程轮流交替执行三种实现方法
沐雨金鳞
07-01 4112
第一种方法：采用公平锁实现 思路及其简单： A线程拿到锁，执行代码 B线程拿到锁，执行代码 A线程拿到锁，执行代码 ...... public class FairLockDemo { public static void main(String[] args) { Runnable target = new Runnable(){ int i = 10; // 利用公平锁 private R
Java多线程
qq_48965607的博客
03-18 310
目录 1.1、多线程的基本概念 1.2、多线程的实现（重点） 1.2.1、继承Thread类实现多线程 1.2.2、实现Runnable接口实现多线程 1.2.4、线程的操作状态 1.3、线程的主要操作方法 1.3.1、线程的命名和取得 1.3.2、线程的休眠 1.3.3、线程的优先级 1.1、多线程的基本概念 如果要想解释多线程，那么首先应该从单进程开始讲起，最早的DOS系统有一个最大的特征：一旦电脑出现了病毒，电脑会立刻死机，因为传统DOS系统属于单...
线程交替运行
weixin_33995481的博客
04-18 63
package threadtest; public class Test1 { /* * 两个线程，一个打印1-100的奇数，一个打印1-100的偶数；要求：线程1打印5个之后，线程2开始打印，线程2打印5个之后，线程1再开始打印，以此循环。 */ private static int state = 1; ...
java线程交替执行_线程之交替执行的实例
weixin_33305349的博客
02-17 406
4.java多线程交替打印A和B?2.Java实现两个线程交替打印问题====4.java多线程交替打印A和B?关键就是打印A和B的方法，synchronized的对象是同一个，即持有的锁是同一个，都是print这个类的实例然后又一个标志，当不是自己的时候，就释放自己的锁，并让线程进入等待状态，就是this.wait()当while执行完后，说明到自己的回合，打印字符，设置标志，然后唤醒锁为thi...
线程交替执行
qq_43430343的博客
10-09 223
线程交替执行打印abcabcabcabcabc wait-notify package demo1; public class JiaoTi1 { public static void main(String[] args) { WaitNofy wn=new WaitNofy(1,5); new Thread(()->{ wn.print("a",1,2); }).start(); new Threa
多线程交替执行
ys.hubery
10-19 540
交替执行
【java多线程编程】三种多线程的实现方式
taojin12的博客
01-01 4万+
文章目录前言进程与线程继承Thread类，实现多线程FAQ 为什么多线程的启动不直接使用run（）方法而必须使用Thread类中start（）方法呢？基于Runnable接口实现多线程Thread 与 Runnable 的关系Callable实现多线程线程运行状态 前言 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;在java语言最大的特点是支持多线程的开发（也是为数不多...
java实战范例
06-24
例如，输出结果显示了两个线程交替打印数组元素，既体现了排序的结果，也展现了线程间的并发执行。 第二个实例则进一步展示了多线程的随机休眠和同步概念。在这个例子中，我们定义了一个名为`MyThread`的类，实现了...
2021 Java面试真题集锦
热门推荐
GL1765852966的博客
12-26 8万+
目录 … 1 大厂面试的基本流程 17 字节跳动 17 阿里 17 腾讯 18 网易游戏 18 面试前需要准备： 18 面试中可以借鉴的套路 19 用简历争取到更多的面试机会 19 自我介绍时，立即全面抛出技术栈和亮点 20 先介绍项目背景，打消面试官疑问 21 通过说项目管理工具，说明你不仅会写代码 22 用 SPRING BOOT 项目举例，说明你的技术基本面 23 用实例说明你在内存调优方面的经验 24 展示你在数据库调优方面的经验 25 总结前文说辞 26 准备项目说辞时，更可以准备后继面试官的问
java线程交替执行_Java中多个线程交替循环执行
weixin_35793067的博客
02-12 418
有些时候面试官经常会问，两个线程怎么交替执行呀，如果是三个线程，又怎么交替执行呀，这种问题一般人还真不一定能回答上来。多线程这块如果理解的不好，学起来是很吃力的，更别说面试了。下面我们就来剖析一下怎么实现多个线程顺序输出。两个线程循环交替打印//首先我们来看一种比较简单的方式public class ThreadCq {public static void main(String[] args) ...
java 线程交替执行_多线程交替运行
weixin_42298093的博客
02-21 523
目标三个线程分别打印a,b,c，需要保证打印顺序是abc思路需要保证线程的执行顺序，本质还是线程之间通信，线程之间的通信有以下几种方式wait()/notify()/notifyAll()使用wait/notify，需要通过临时变量来控制，当前是否打印，在线程打印完毕后更新临时变量的值，并唤醒所有等待中的线程，等待中的线程唤醒后，通过比较新的临时变量值，是否是自己想要的值来决定是继续等待，还是执行...
java多线程 线程交替执行（同步）的各种实现方案
最新发布
qq_43800449的博客
05-14 1708
如果想要指定执行顺序，则需要用信号量，或者自己实现一个标志位去模拟信号量如果不需要指定执行顺序，则谁先竞争到锁就谁先执行，执行完后唤醒另一个线程，再进入wait状态。
java线程交替执行_Java synchronized线程交替运行实现过程详解
weixin_39714849的博客
02-12 202
背景用两个线程交替输出A-Z和1-26，即一个线程输出A-Z，另一个线程输出1-26而且是交替形式线程1输出A——线程二输出1线程1输出B——线程二输出2线程1输出C——线程二输出3以此类推分析主要考察线程之间的通信，思路就是创建两个线程在一个线程输出一个内容之后，自己进入阻塞，去唤醒另一个线程另一个线程同样，输出一个内容之后，自己进入阻塞，去唤醒另一个线程代码实现(一)public class ...
java两个线程交替执行
keitho00的专栏
07-25 1万+
这个问题的来源是一个题目：线程A循环10次，线程B循环100，接着又回到线程A循环10次，接着再回到线程B又循环100，如此循环50次。 一般来说线程锁可以用：synchronized、Lock。 这个题目的难点不在于同步块，而在于怎么样设计这个两个线程的交替实现。由于线程争用cpu的随机性，就需要A线，B线程执行，在B执行完一次进入等待之前唤醒A，如此往复，那么这里就要用上notify和wa
两个线程交替打印1-100之间的数字
weixin_56846554的博客
03-23 2477
文章目录。
渐进式web应用程序_渐进式Web应用程序终极指南
culiu9261的博客
07-20 1235
渐进式web应用程序Progressive Web Apps, aka PWAs, are the best way for developers to make their webapps load faster and more performant. In a nutshell, PWAs are websites that use recent web standards to allow...
AndroidStudio 线程
appiox8的博客
06-12 2265
package com.example.sofia.testactivityactive; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; public class MainActivity extends AppCompa
Java多线程交替执行任务
lygsust的博客
09-13 3697
一：问题描述          生活中很多事情都是有顺序的交互进行着,比如100个人去做地铁,安检的只负责安;只有安检通过了，才能排队刷卡进站;进站了，在对应线路站下排队才能进站。这就是一个典型的多任务有顺序的进行。对于每一个人来说都有顺序要经过这几步。         我们可以通过程序简单的抽象成,使用三个线程，每个线程分别只打印A、B、C. 依次打印出十组ABC. 二：实现思路：
Java图形界面多线程实战：快慢线程交替运行
在run()方法内部，使用了一个无限循环，确保线程可以持续运行。循环中，首先打印出线程的名字和当前时间，然后让线程休眠指定的时间（time毫秒）。如果在休眠过程中发生异常，如InterruptedException，将会捕获并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值