更好的中断线程Java的方法

时间:2014-07-04 10:12:19

标签: java multithreading

我用Java编写了一个类:

public class Main {
    public static boolean firstRunning = true;
    public static void main(String[] args) {
        (new Thread(){
            public void run(){
                secondFunction();
            }
        }).start();
        firstFunction();
    }

    public static void firstFunction()
    {
        for(int i = 0; i < 10 && firstRunning; i++)
        {
            try{Thread.sleep(1000);} catch(Exception e){}
            System.out.println("first - "+i);
        }
        return;
    }

    public static void secondFunction(){
        try{Thread.sleep(3000);} catch(Exception e){}
        firstRunning = false;
        for(int i = 0; i < 10; i++)
        {
            try{Thread.sleep(700);} catch(Exception e){}
            System.out.println("second - "+i);
        }
    }
}

我在新线程中调用secondFuntion(),之后我开始在firstFuntion()中执行Main Thread。在Thread.sleep(3000)中执行secondFuntion()后,我想让secondFunction()接管Main Thread,为此我将布尔标志firstRunning设置为false并使用return语句取消Main Thread的执行。

这种方法对我有用,但有更优雅的方法吗?

修改

代码的输出是

first - 0
first - 1
first - 2
second - 0
second - 1
second - 2
second - 3
second - 4
second - 5
second - 6
second - 7
second - 8
second - 9

3 个答案:

答案 0 :(得分:0)

如果你只想让主线程退出,那么这是最简单的方法。

但通常情况下,您有更复杂/不同的需求。我的猜测是你试图解决另一个问题,这是你的第一个解决方案。除非你告诉我们你原来的问题,否则我们无法告诉你一个好的解决方案。

如果您只想要2个线程共享某些内容(即不同时使用它),则可以使用锁定(请参阅Java 7 docs)。

伪代码:

  • 主线程创建锁
  • 主线程创建第二个线程并将锁传递给它
  • 第一个函数尝试获取循环内部的锁。当它成功时,它会运行一次循环体并释放锁定。
  • 线程2然后使用锁来确保主线程在其工作时阻塞

答案 1 :(得分:0)

在我看来,没有必要主动等待。更优雅的方法是使用CountDownLatch来解决这个特定问题。如果你希望主线程等到另一个线程执行一个操作,你可以使用这样的CountDownLatch:

public class Main {
   private static final CountDownLatch latch = new CountDownLatch(1);
   public static void main(String[] args) throws InterruptedException {
       (new Thread(){
           public void run(){
               secondFunction();
           }
       }).start();
       firstFunction();
       System.out.println("DONE!");
   }

    public static void secondFunction(){
        latch.await(); // blocks the main thread here until 
                       // the latch has been counted down to 0
    }

   public static void secondFunction(){
       System.out.println("secondFunction 1");
       try{Thread.sleep(3000);} catch(Exception e){}
       System.out.println("secondFunction 2");
       latch.countDown(); // this counts down the latch from 1 to 0 and
                          // releases the initial thread from blocking
       // ... continue with some other operations
   }

输出:

secondFunction 1
secondFunction 2
DONE!

有关详细信息,请查看Java documentation。这种方法的替代方法和在Java中解决线程等待问题的“标准”方法是使用synchronize / wait / notify的所谓“监视”概念。请查看this stackoverflow post示例。

答案 2 :(得分:-2)

由于您的真正问题不明确,只是为了实现您的输出,您可以使用以下代码。它使用java中的Threads给出的同步,等待/通知功能:

public class Main {
    private static Thread t1;
    private static Object lock = new Object();//dummy object to perform sychronization
    public static void main(String[] args) {
        t1 = new Thread(){
            public void run(){
                secondFunction();
            }
        };
        t1.start();
        firstFunction();
    }

    public static void firstFunction()
    {
        for(int i = 0; i < 10; i++)
        {
            if(i == 3){
                 synchronized (lock) { // wait till the lock is available 
                    try {
                        lock.wait(); // wait till some thread notifies
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            try{Thread.sleep(1000);} catch(Exception e){}
            System.out.println("first - "+i);
        }
        return;
    }

    public static void secondFunction(){
        try{Thread.sleep(3000);} catch(Exception e){} //wait for 3 sec to run the main thread 3 times
        synchronized (lock) { //aquire the lock
             for(int i = 0; i < 10; i++)
             {
                 try{Thread.sleep(700);} catch(Exception e){}
                 System.out.println("second - "+i);
             }
               //don't notify the main thread that this thread is done with lock
        }
    }
}

由于代码没有通知&#34;锁定&#34;通过第二个函数和新线程不再使用,主线程将继续等待通知。

输出与给定的相同。

警告:这不是使用锁和同步的好方法,而只是举例说明如何使用线程锁/同步。如果您的真正问题已经明确,我们会为此确定最好的方法