精华内容
下载资源
问答
  • * 要求:两个线程交替打印从1到100的数字。 */ public class PrintSD { //定义打印的方法 public synchronized void print(String str,int num){ notify(); System.out.println(str+num); try { if(100 != ...
    /***
     * 要求:两个线程交替打印从1到100的数字。
     */
    public class PrintSD {
    
        //定义打印的方法
        public synchronized void print(String str,int num){
            notify();
            System.out.println(str+num);
            try {
                if(100 != num){
                    wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        //奇数打印线程
        class Odd implements Runnable{
            @Override
            public void run() {
                for(int i=1;i<100;i+=2){
                    print("奇数:",i);
                }
            }
        }
    
        //偶数打印线程
        class Even implements Runnable{
            @Override
            public void run() {
                for(int i=2;i<=100;i+=2){
                    print("偶数:",i);
                }
            }
        }
    
        public static void main(String[] args) {
            PrintSD p = new PrintSD();
            Odd odd = p.new Odd();
            Even even = p.new Even();
            new Thread(odd).start();
            new Thread(even).start();
        }
    }
    
    
    
    展开全文
  • 关于ReentrantLock的实现原理,详见这篇:...为什么要用ReentrantLock呢,因为这里交替打印线程交替执行),需要对共享变量flag进行反复...

    关于ReentrantLock的实现原理,详见这篇:https://github.com/crossoverJie/JCSprout/blob/master/MD/ReentrantLock.md

    ReentrantLock实现交替打印奇偶数,就是开两个线程,一个打印奇数,一个用于打印偶数。
    为什么要用ReentrantLock呢,因为这里交替打印(线程交替执行),需要对共享变量flag进行反复的加锁。所以如果用synchronized来进行同步的话,可能会造成自己阻塞自己,最后形成死锁。所以这里用到了重入锁ReentrantLock。

    下面贴上代码:

    package actual;
    
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class TwoThread {
    	
    	private int start = 1;
    	
    	//对 flag 的写入虽然加锁保证了线程安全,但读取的时候由于 不是 volatile 所以可能会读取到旧值
    	private volatile boolean flag = false;
    	
    	//重入锁,ReentrantLock
    	private final static Lock lock = new ReentrantLock();
    	
    	public static void main(String[] args){
    		TwoThread twoThread = new TwoThread();
    		
    		Thread t1 = new Thread(new JiNum(twoThread));
    		t1.setName("t1");
    		
    		Thread t2 = new Thread(new OuNum(twoThread));
    		t2.setName("t2");
    		
    		t1.start();
    		t2.start();
    	}
    	
    	//奇数线程
    	public static class JiNum implements Runnable{
    
    		private TwoThread number;
    		
    		public JiNum(TwoThread number){
    			this.number = number;
    		}
    		
    		@Override
    		public void run() {
    			while(number.start <= 100){
    				if(!number.flag){
    					try{
    						lock.lock();
    						System.out.println(Thread.currentThread().getName() + "+-+" + number.start);
    						number.start ++ ;
    						number.flag = true;
    					}finally{
    						lock.unlock();
    					}
    				}
    			}
    		}
    		
    	}
    	
    	//偶数线程
    	public static class OuNum implements Runnable{
    
    		private TwoThread number;
    		
    		public OuNum(TwoThread number){
    			this.number = number;
    		}
    		
    		@Override
    		public void run() {
    			while(number.start <= 100){
    				if(number.flag){
    					try{
    						lock.lock();
    						System.out.println(Thread.currentThread().getName() + "+-+" + number.start);
    						number.start ++ ;
    						number.flag = false;
    					}finally{
    						lock.unlock();
    					}
    				}
    			}
    		}
    	}
    }
    
    

    结果:
    在这里插入图片描述

    展开全文
  • JDK1.8新特性, 多线程交替打印奇偶数 package demo; import org.omg.PortableInterceptor.SYSTEM_EXCEPTION; /** * @ClassName 交替打印奇偶数 * @Description 这里描述 * @Author admin * @Date 2021/3/16 ...

    JDK1.8新特性, 多线程交替打印奇偶数

    package demo;
    
    import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
    
    /**
     * @ClassName 交替打印奇偶数
     * @Description 这里描述
     * @Author admin
     * @Date 2021/3/16 8:43
     */
    public class OddEvenThreadDemo {
    
        static final Object object = new Object();
    
        public static void main(String[] args) {
    
            new Thread(   () ->{
                synchronized (object){
                    for(int i=1;i<100;i +=2){
                        System.out.println(Thread.currentThread().getName()+",i:"+i);
                        object.notify();
                        try {
                            object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
    
                };
            }).start();
    
            new Thread(() ->{
                synchronized (object){
                    for(int i=2;i<100;i +=2){
                        System.out.println(Thread.currentThread().getName()+",i:"+i);
                        object.notify();
                        try {
                            object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
    
                };
            }).start();
    
        }
    
    
    }
    

     

    展开全文
  • public class PrintOdd implements Runnable { private int i = 1; @Override public void run() { synchronized (this) { while (i ) { if (i%2 != 0) { try { CM.ptl(i);...
    public class PrintOdd implements Runnable {
    	private int i = 1;
    
    	@Override
    	public void run() {
    		synchronized (this) {
    			while (i <= 10) {
    				if (i%2 != 0) {
    					try {
    						CM.ptl(i);
    						i++;
    						notify();
    						wait();
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				} else {
    					try {
    						CM.ptl(i);
    						i++;
    						notify();
    						wait();
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    			notify();
    		}
    	}
    
    	public static void main(String args[]) {
    		PrintOdd odd = new PrintOdd();
    		Thread thread = new Thread(odd);
    		Thread thread2 = new Thread(odd);
    		thread.start();
    		thread2.start();
    	}
    }

    展开全文
  • 如何实现两个线程交替打印1-100之内的奇偶数? 2,解决方案 首先进行问题分析,两个线程交替打印奇偶数,涉及到的是两个线程间的通信和协作问题。我们知道,java实现线程间通信的方式通常是加锁和唤醒,最常用的是...
  • 多线程:两个线程交替打印奇偶数

    千次阅读 2018-08-22 14:17:35
    要求:两个线程交替打印从1到100的数字。
  • 两个线程交替打印奇偶数-学习笔记

    千次阅读 2018-08-15 22:26:28
    而前天刚好看见阿里大哥专门讲这个程序的博客《多线程技术: 两个线程交替打印奇数和偶数 - 明志健致远 - 博客园》。 主要是看到安徽建筑大学的字样,回想到那篇文章里大哥的自我介绍,觉得肯定就是那大哥。 看了...
  • 本质上,还是利用了隐式锁synchronized锁住对象,然后再利用对象的wait和notify来实现。 /** * @author lufan * @date 2019/11/14 */ public class Demo { int num = 100;... * 打印奇偶数方法 * @param ...
  • 我们将通过“两个线程交替打印100内的奇偶数”,来展示下`wait()`方法和`notify()`方法的用法和优点,当然要体现出优点,自然要通过对比不使用这两个方法实现同一功能的代码,通过这几篇文章的讲解,帮你彻底搞懂`...
  • 思路:利用Object.wait()和Object.notify()方法进行线程间的通信。 代码: public class MyThread implements Runnable { private static int i = 1; private byte[] s1; public MyThread(byte[] s1) { ...
  • /** * @author: 刘磊 * @Description: 交替打印奇偶数 * @date: 2019/3/26 14:07 **/ public class Test { static class NUM{ int i = 0; } static NUM num = new NUM(); @org.junit.Test p...
  • 构造两个线程交替打印1-100之间的数字,其中线程1打印奇数,线程2打印偶数。 方式1:采用synchronized同步锁和wait,notify线程通信机制来实现。 public class jiaotidayinshuzi { public static void main...
  • #include<iostream> #include<mutex> #include<thread> #include<condition_variable> #include<Windows.h> using namespace std;...//线程1 void thread1() { while (1) { un
  • 主要介绍了Java 实现多线程切换等待唤醒交替打印奇偶数 ,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 实现思想主要是让两个线程互相唤醒对方来交替打印数字 #include <unistd.h> #include <stdlib.h> #include <pthread.h> #include <stdio.h> int g_num = 1; pthread_mutex_t mutex; ...
  • 两个线程都持有相同的一个信号量,奇数线程启动,获取信号量,然后打印完,释放信号量,再休眠,然后偶数线程启动,获取信号量,然后打印完,释放信号量 package demo6; import java.util.concurrent.Semaphore; /...
  • import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Solution { private int start = 1... * 对flag的写入虽然加锁保证了线程安全,但由于读取时不是...
  • 两个线程交替打印奇偶数的问题
  • 如何利用多线程交替输出奇偶数 更多干货见博主个人网站:https://blog.zhenglin.work 用两个线程分别输出奇数、偶数 思路:两个线程,一个输出奇数,一个输出偶数;说明这两个线程公用一个数据池。一个线程输出...
  • public static void main(String[] args) { /** 此处()->匿名函数相当于 new Runnable(){ @Override public void run()} **/ new Thread(()->{ while(count){ if((count&1)==0) { //如果是偶数,给当前线程方法加锁 ...
  • Object,notify()作用是唤醒持有这个Object对象锁的线程, Object,wait()作用是让当前线程进入阻塞状态。 因此 notify和wait只能用于synchronized内部,因为synchronized会指定对象锁, 而wait的前提是当前线程持有锁...
  • 写一个demo实现多线程交替打印ABC,同理也可实现交替打印奇数偶数等;供小伙伴们参考 1 import java.util.concurrent.atomic.AtomicInteger; 2 3 public class ThreadDemo { 4 volatile static int count...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,787
精华内容 714
关键字:

多线程交替打印奇偶数