2个线程交替出现

Question

        MyThread th1=new MyThread();
        MyThread th2=new MyThread();
        new Thread(th1).start();
        new Thread(th2).start();class MyThread implements Runnable
{
    public int i;
    public void run()
    {
        for(i=0;i<1000;i++)
            System.out.println(i);
    }
}
运行结果是一个线程跑很快 另一个就只加了几个
怎么让显示结果是 1 1 2 2 3 3.... 这样的出现啊
还有怎么计算一个线程做完用了多少时间啊~

Answer 1

怎么让显示结果是 1 1 2 2 3 3
线程加一之后,用Thread.sleep()等一段时间.怎么计算一个线程做完用了多少时间
你可以用时间差来计算!
long t1 = System.currentTimeMillis(); 
//这里调用你的程序
long t2 = System.currentTimeMillis(); 
System.out.println(int)((t2-t1)/1000) " seconds "((t2-t1) % 1000) " micro seconds"); 

Answer 2

线程调用是系统做的，很有可能它只调用A，A执行完才调用B，这都是不确定的
所以你必须人工的控制你的线程调用
麻烦一点，就是A线程输出一个数，然后自己暂停，再开B
B线程输出一个数，自己暂停，再开A简单一点嘛，就是做个时间差出来，但是这种方法不保证一定成功
只是利用系统处理远快于你设的时间差这个特点，当然这种方法会大大降低你的程序的效率
如果下面这段程序可以实现，你可以把时间差都缩小10倍再试试看，如果成功了，再缩小5倍试试看
多运行几遍，都成功的话，就可以将就着用了MyThread th1=new MyThread();
        MyThread th2=new MyThread();
        new Thread(th1).start();
        Thread.sleep(50);
        new Thread(th2).start();
class MyThread implements Runnable
{
    public int i;
    public void run()
    {
        for(i=0;i <1000;i++) {
            System.out.println(i);
            Thread.sleep(100);
        }
    }
} 

Answer 3

使用一个变量,加上判断语句,单数次为 A 线程,双数次为 B 线程
在循环里面加上 if(i==0)<在这里执行获取时间的函数> if(i==1000-1)<在这里执行获取时间的函数>
把后面那个减前面的 ok 

Answer 4

两个线程里 分别标记运行时候的时间和结束时候的时间用：System.currentTimeMillis()方法
最后统计两个时间差就可以了......

Answer 5

记录开始时间和结束时间，时间差就是运行时间但是这种方法用来判断排序算法的优劣是不准确的
因为，很有可能A刚一开始，就被挂起，其它线程执行完了，它才继续，
那么这个A的排序算法就会执行很长时间，得出算法不好的结论，其实是系统调用的错但是既然你这是题目，非要多线程同时计算的话，那么建议你除了记录一次执行的时间外
还应该在启动多线程的外面再包一层，也就是把这些线程启动个10000次，然后最后都运行完了，给各个算法算个平均时间
（注意尽量把开始时间和结束时间的取得时点，设在紧贴你的算法外面）thread-----run {
。其它代码
开始时间取得
算法开始
算法结束
结束时间
。其它代码
}

Answer 6

这两个线程不是同步的所以出现这样的结果是对的他们都是同时执行的，你可以currentThread().getName()看出你那些112233的值是哪个线程打印出来的

Answer 7

class MyThread implements Runnable 
{ 
public void run() 
{ 
int i;

for(i=0;i <50;i++)
{
synchronized(this)
{
try
{
notify();
System.out.println(Thread.currentThread().getName());
System.out.println(i);
if(i != 49)
{
wait();
}
}catch(Exception e)
{ }
}
}

}} 
class TestThread
{
public static void main(String[] args)
{
MyThread th1=new MyThread(); 
new Thread(th1).start(); 
new Thread(th1).start();
}
}
这个方法可得到楼主想要的，时间可参考3楼的

Answer 8

public class MyThread extends Thread
{
    public int i;    private boolean isA = false;    LockObject lock = null;    public MyThread(boolean isA, LockObject lock)
    {
        this.isA = isA;
        this.lock = lock;
    }    public void run()
    {
        long t1 = System.currentTimeMillis();
        // 这里调用你的程序        for (i = 0; i < 100; i++)
        {
            synchronized (lock)
            {
                if (isA == lock.getTurn())
                {
                    System.out.println(this.getName() + ":" + i);
                    lock.setTurn(!isA);
                    try
                    {
                        Thread.sleep(50);
                    }
                    catch (InterruptedException e1)
                    {
                        //捕获异常：异常处理
                        e1.printStackTrace();
                    }
                    lock.notify();                    // 结束了，就不再等待了
                    if (i < 100 - 1)
                    {
                        try
                        {
                            lock.wait();
                        }
                        catch (InterruptedException e)
                        {
                            // 捕获异常：异常处理
                            e.printStackTrace();
                        }
                    }                }
            }        }        long t2 = System.currentTimeMillis();
        System.out.println(this.getName() + " 耗时:" + (int) ((t2 - t1) / 1000)
                + " seconds " + ((t2 - t1) % 1000) + " micro seconds");
    }    public static void main(String[] args)
    {
        LockObject lock = new LockObject();
        MyThread th1 = new MyThread(true, lock);
        MyThread th2 = new MyThread(false, lock);
        th1.start();
        th2.start();
    }
}public class LockObject
{
    private boolean isTurnA = true;    public synchronized boolean getTurn()
    {        return isTurnA;
    }    public synchronized void setTurn(boolean isTurn)
    {
        isTurnA = isTurn;
    }
}

Answer 9

请问我看到有2种方法创建线程
一个是Thread类实现run()方法然后Thread.start()开始线程
一个是SwingWorker类实现doINBackground方法然后再execute()执行它们的区别是什么 仅仅是第二个是在可视化的是时候用吗? 

Answer 10

SwingWorker不是标准JDK里面的东东吧?
线程的创建就只有Thread, Runnable