请问使用两个线程分别输出100以内的奇数和偶数，并按从小到大的顺序输出如何操作？

0 0

请问使用两个线程分别输出100以内的奇数和偶数，并按从小到大的顺序输出如何操作？5

]public synchronized void run(){
oushu();

qishu();
}
public void oushu(){ //偶数
for (int i = 0; i < 101; i++) {
if(i%2==0){
System.out.println(Thread.currentThread().getName()+i);
}
}
}
public void qishu(){ //奇数
for (int i = 0; i < 101; i++) {
if(i%2!=0){

引用

System.out.println(Thread.currentThread().getName()+i);
}
}
}

这是我写的，这样写的话永远都不对

问题补充：public class Test {
public static void main(String[] args) {
Shuju sj=new Shuju();
Thread ou=new Thread(sj);
Thread qi=new Thread(sj);
ou.setName("偶数为：");
qi.setName("奇数为：");
ou.start();
qi.start();
}

}

2014年5月25日 00:42

小猪猪08
3
0 0 4

4个答案按时间排序按投票排序

0 0

采纳的答案

例如产生的奇数和偶数： 1,2,3,4 这样？如果是这样应该是不行的那个线程片段性的执行，就是有段时间是线程ou执行有段时间是线程qi执行但是执行的时候貌似是不能控制每个线程执行循环的次数所以2个线程排序有点困难的

2014年5月25日 03:34

lao1984wang
617
0 0 24

1条评论

0 0

public class Test15 implements Runnable{

int start=1;
public Test15(int start){
this.start=start;
}
@Override
public void run() {
StringBuffer result= new StringBuffer(start+"");
for(int i=0;i<49;i++){
result.append(",");
result.append(start+(i+1)*2);
}
System.out.println(result.toString());
}

public static void main(String[] args){
new Thread(new Test15(1)).start();
new Thread(new Test15(2)).start();
}
}

2014年5月26日 11:00

hufangxian
37
0 0 17

添加评论

0 0

呵呵，楼主这两个循环都可以把步长调整为每次+2，这样可以把里面判断为奇数还是偶数的代码省了。
这样，第一段执行完了之后，再让第二个线程开始执行，这个过程可以使用CountDownLatch来控制。
或者使用阻塞队列，所有这些数据放到队列中，每个线程消费一个之后wait，同时notify让另一个线程来执行，这样达到分别输出的目的。

2014年5月25日 10:19

chainhou
192
0 0 15

2条评论

0 0

可以用个线程池里面丢两个线程跑的
如下：
import java.util.concurrent.atomic.AtomicInteger;

public class OddNumber implements Runnable
{
    private int maxNumber;
    private AtomicInteger number;
    private Object lock;
    
    public OddNumber(int maxNumber, AtomicInteger number, Object lock)
    {
        this.maxNumber = maxNumber;
        this.number = number;
        this.lock = lock;
    }
    
    public void run()
    {
        print();
    }
    
    public void print()
    {
        while (number.get() < maxNumber + 1)
        {
            if (number.get() % 2 == 0)
            {
                System.out.println(Thread.currentThread().getName() + " --> " + number.getAndAdd(1));
                
                synchronized (lock)
                {
                    lock.notifyAll();
                }
            }
            else
            {
                synchronized (lock)
                {
                    try
                    {
                        lock.wait(); //wait for the lock
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
}


import java.util.concurrent.atomic.AtomicInteger;

public class EvenNumber implements Runnable
{
    private int maxNumber;
    private AtomicInteger number;
    private Object lock;
    
    public EvenNumber(int maxNumber, AtomicInteger number, Object lock)
    {
        this.maxNumber = maxNumber;
        this.number = number;
        this.lock = lock;
    }
    
    public void run()
    {
        print();
    }
    
    public void print()
    {
        while (number.get() < maxNumber + 1)
        {
            if (number.get() % 2 != 0)
            {
                System.out.println(Thread.currentThread().getName() + " --> " + number.getAndAdd(1));
                
                synchronized (lock)
                {
                    lock.notify(); //
                }
            }
            else
            {
                synchronized (lock)
                {
                    try
                    {
                        lock.wait();  //wait for the lock
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
}

package com.mycompany.app6;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class PrintOddEvenNumbersWithTwoThreads
{
    public static void main(String[] args)
    {
        final int max = 10;
        final AtomicInteger i = new AtomicInteger(1); //start with 0
        Executor dd = Executors.newFixedThreadPool(2);
        
        final Object lock = new Object();
        
        dd.execute(new OddNumber(max, i, lock));
        dd.execute(new EvenNumber(max, i, lock));
        
        do
        {
            try
            {
                Thread.sleep(1000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        
        while (i.get() != max + 1);
        
        System.out.println("\nDone");
        System.exit(0);
    }
}

2014年5月25日 07:58