java多线程题目01

题目:两个线程交替顺序打印,一个输出正整数1到52,一个输出a-zA-Z,

例如 - 1a2b3c4d5e6f7g8h9i10j11k12l13m14n15o16p17q18r19s20t21u22v23w24x25y26z

27A28B29C30D31E32F33G34H35I36J37K38L39M40N41O42P43Q44R45S46T47U48V49W50X51Y52Z

一、使用volatile

二、使用Semaphore

三、思路: 一个线程等待,一个线程唤醒,始终只有一个线程执行

a. volatile

public class NumberDemo {
    static class Inner {
        private volatile boolean flag = true;
        private int count = 1;
        private int index = 1;

        public synchronized void printNum() {
            try {
                while (!flag) {
                    this.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print(count++);
            flag = false;
            this.notify();
        }

        public synchronized void printChar() {
            try {
                while (flag) {
                    this.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (index < 27) {
                System.out.print((char) (index + ‘a‘ - 1));
            } else {
                System.out.print((char) (index + ‘A‘ - 27));
            }
            index++;
            flag = true;
            this.notify();
        }
    }

    public static void main(String[] args) {
        Inner inner = new Inner();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 52; i++) {
                    inner.printNum();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 52; i++) {
                    inner.printChar();
                }
            }
        }).start();
    }
}

  b. Semaphore

public class NumberSemaphoreDemo {

    static class Inner {

        private Semaphore semaphore = new Semaphore(1);

        private int count = 1;
        private int index = 1;

        public synchronized void printNum() {
            try {
                semaphore.acquire();
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print(count++);
            semaphore.release();
            this.notify();
        }

        public synchronized void printChar() {
            try {
                semaphore.acquire();
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (index < 27) {
                System.out.print((char) (index + ‘a‘ - 1));
            } else {
                System.out.print((char) (index + ‘A‘ - 27));
            }
            index++;
            semaphore.release();
            this.notify();
        }
    }

    public static void main(String[] args) {
        NumberDemo.Inner inner = new NumberDemo.Inner();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 52; i++) {
                    inner.printNum();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 52; i++) {
                    inner.printChar();
                }
            }
        }).start();
    }
}

  

原文地址:https://www.cnblogs.com/maduar/p/10605674.html

时间: 2024-10-18 19:08:33

java多线程题目01的相关文章

Java多线程并发09——如何实现线程间与线程内数据共享

本文将为各位带来 Java 阻塞队列相关只是.关注我的公众号「Java面典」了解更多 Java 相关知识点. 线程间数据共享 Java 里面进行多线程通信的主要方式就是共享内存的方式,共享内存主要的关注点有两个:可见性和有序性原子性.Java 内存模型(JMM)解决了可见性和有序性的问题,而锁解决了原子性的问题,理想情况下我们希望做到"同步"和"互斥".有以下常规实现方法: 将数据抽象成一个类 将数据抽象成一个类,并将对这个数据的操作作为这个类的方法,这么设计可以和

【华为OJ】201301 JAVA 题目0-1级 将数组分为相等的两组

描述:  编写一个函数,传入一个int型数组,返回该数组能否分成两组,使得两组中各元素加起来的和相等,并且,所有5的倍数必须在其中一个组中,所有3的倍数在另一个组中(不包括5的倍数),能满足以上条件,返回true:不满足时返回false. 知识点: 语言基础,字符串,循环,函数,指针,枚举,位运算,结构体,联合体,文件操作,递归    题目来源: 内部整理  练习阶段: 初级  运行时间限制: 10Sec 内存限制: 128MByte 输入: 输入输入的数据个数 输入一个int型数组 输出: 返

Java多线程系列--“基础篇”01之 基本概念

多线程是Java中不可避免的一个重要主体.从本章开始,我们将展开对多线程的学 习.接下来的内容,是对“JDK中新增JUC包”之前的Java多线程内容的讲解,涉及到的内容包括,Object类中的wait(), notify()等接口:Thread类中的接口:synchronized关键字. 注:JUC包是指,Java.util.concurrent包,它是由Java大师Doug Lea完成并在JDK1.5版本添加到Java中的. 在进入后面章节的学习之前,先对了解一些多线程的相关概念.线程状态图

java多线程系类:JUC集合:01之框架

概要 之前,在"Java 集合系列目录(Category)"中,讲解了Java集合包中的各个类.接下来,将展开对JUC包中的集合进行学习.在学习之前,先温习一下"Java集合包".本章内容包括:Java集合包JUC中的集合类 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3498454.html Java集合包 在"Java 集合系列01之 总体框架"中,介绍java集合的架构.主体内容包括Colle

java多线程系类:JUC线程池:01之线程池架构

概要 前面分别介绍了"Java多线程基础"."JUC原子类"和"JUC锁".本章介绍JUC的最后一部分的内容--线程池.内容包括:线程池架构图线程池示例 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3509903.html 线程池架构图 线程池的架构图如下: 1. Executor 它是"执行者"接口,它是来执行任务的.准确的说,Executor提供了execute()接口来执行

Java多线程系列--“JUC线程池”01之 线程池架构

概要 前面分别介绍了"Java多线程基础"."JUC原子类"和"JUC锁".本章介绍JUC的最后一部分的内容——线程池.内容包括:线程池架构图线程池示例 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3509903.html 线程池架构图 线程池的架构图如下: 1. Executor 它是"执行者"接口,它是来执行任务的.准确的说,Executor提供了execute()接口来执行

Java多线程01(Thread类、线程创建、线程池)

Java多线程(Thread类.线程创建.线程池) 第一章 多线程 1.1 多线程介绍 1.1.1 基本概念 进程:进程指正在运行的程序.确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能. 线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程.一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序. 简而言之:一个程序运行后至少有一个进程,一个进程中可以包含多个线程 1.1.2 单线程程序 - 从入口m

Java多线程系列--“JUC锁”11之 Semaphore信号量的原理和示例

概要 本章,我们对JUC包中的信号量Semaphore进行学习.内容包括:Semaphore简介Semaphore数据结构Semaphore源码分析(基于JDK1.7.0_40)Semaphore示例 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3534050.html Semaphore简介 Semaphore是一个计数信号量,它的本质是一个"共享锁". 信号量维护了一个信号量许可集.线程可以通过调用acquire()来获取信号量的许可

Rhythmk 一步一步学 JAVA (21) JAVA 多线程

1.JAVA多线程简单示例 1.1 .Thread  集成接口 Runnable 1.2 .线程状态,可以通过  Thread.getState()获取线程状态: New (新创建) Runnable (可以运行) Blocked  (被阻塞) Waiting  (等待) Timed waiting (计时等待) Terminated  (被终止) ? 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