Java 锁定或同步

我有一个调用另一个线程的主线程。第二个的超时时间为15秒。当前实现是主线程检查，每2秒检查一次。我需要做的是只等待第二个线程完成，最多15秒。我曾想过尝试等待和通知，但这将需要同步。我正在考虑使用锁。我以前没试过。请帮我做这个

谢谢

这个想法可以实现吗？通过在第一个线程中的锁对象上使用timedwait。完成后的第二个线程应通知锁对象。这将唤醒第一个线程。此外，timedwait将强制最大等待15秒

更新了解决方案，我尝试了

public class MyThread {

Object obj = new Object();
boolean isDone = false;
int timeOut = 0;
int runTime = 0;    
int id = 0;

public static void main(String[] args) throws Exception {       
    MyThread mainThread = new MyThread();

    mainThread.timeOut = Integer.valueOf(args[0]);
    mainThread.runTime = Integer.valueOf(args[1]);
    System.out.println("<---- mainThread.timeOut ---------->" + mainThread.timeOut);
    System.out.println("<---- mainThread.runTime ---------->" + mainThread.runTime);
    ChildThread childThread = new ChildThread(mainThread);
    childThread.start();        
    try {
        synchronized (mainThread.obj) {
            //Wait the current Thread for 15 seconds
            mainThread.obj.wait(mainThread.timeOut * 1000);
        }       
        System.out.println("<---- runTime Over ---------->");
        if (mainThread.isDone)
            System.out.println("<---- done ---------->");
        else
            System.out.println("<----  not done ---------->");
    } catch (InterruptedException e) {          
        e.printStackTrace();
    }
}

public void test() {        
    System.out.println("<--- In business Test method --->");    
    try {
        //Call the bussiness method which may take more time
        Thread.sleep(runTime * 1000);
        if (runTime <= timeOut)
            isDone = true;
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("<---- completes business test method -->");
}
}

class ChildThread extends Thread {          
    MyThread mainThread;
    ChildThread(MyThread mainThread) {
        this.mainThread = mainThread;
    }

    public void run() { 
        System.out.println("ChildThread: the run method");
        mainThread.test();
        //Finished the work,notify the waiting thread.
        synchronized(mainThread.obj) {
            mainThread.obj.notify();
        }
    }   
}

公共类读取{
Object obj=新对象（）；
布尔isDone=false；
int超时=0；
int运行时=0；
int id=0；
公共静态void main（字符串[]args）引发异常{
MyThread主线程=新的MyThread（）；
mainThread.timeOut=Integer.valueOf（args[0]）；
mainThread.runTime=Integer.valueOf（args[1]）；
System.out.println（“+mainThread.timeOut”）；
System.out.println（“+mainThread.runTime”）；
ChildThread ChildThread=新的ChildThread（主线程）；
childThread.start（）；
试一试{
已同步（mainThread.obj）{
//等待当前线程15秒
mainThread.obj.wait（mainThread.timeOut*1000）；
}       
System.out.println（“”）；
if（mainThread.isDone）
System.out.println（“”）；
其他的
System.out.println（“”）；
}捕获（中断异常e）{
e、 printStackTrace（）；
}
}
公共无效测试（）{
System.out.println（“”）；
试一试{
//调用可能需要更多时间的业务方法
线程睡眠（运行时*1000）；
if（runTime使用
acquire（）
让等待的线程阻塞，并让信令线程使用
release（）
将其递增

详细说明
信号量是一个保持计数的同步原语。此计数没有内在意义，但通常表示有多少某种“资源”是“可用的”。信号量有两个基本操作：递增和递减。递增从不阻塞。如果信号量的计数为零，递减将阻塞，当另一个线程递增信号量时，将取消阻塞。如果在递减时阻塞多个线程，则每次递增只会取消阻塞一个线程

在本例中，您创建了一个两个线程可以访问的初始计数（“
允许”
”）为零的信号量。第一个线程通过减少信号量来等待，这会阻止线程，直到第二个线程增加信号量。
使用WaitForSingleObject（）函数，该函数在指定对象处于信号状态或超时间隔结束时返回

WaitForSingleObject(hThread, 15000);

其中hThread是第二个线程的句柄。
听起来未来任务适合您的用途。请参阅

基本思想是，您可以将第二个线程转换为可调用线程，然后将其包装到FutureTask中。然后，您可以在FutureTask上暂停后调用get。
我已经用答案更新了问题。
我不知道原始海报，但我对这个问题的答案感兴趣，但不理解它…您能解释一下sem是什么吗aphore就在这种情况下？（我怀疑，一旦我明白了其余的事情就会变得清楚）你好，马塞洛。你能详细地告诉我，我是新来的并发软件包吗？Thanks@DEV-查看
java.util.concurrent.CountDownLatch
。您将创建一个构造函数参数为
1
。您的主线程将调用
await（）
（可以选择接受超时）完成后，第二个线程会做它的事情，调用<代码> CurtDuff[/]代码。你可以指定（编辑标签）C？+？C++ 1。原始问题：“当前实现是主线程，每2秒检查第二个。”我没有java的经验，但是下面的链接可能会有帮助：WaistFuxLangObjult（）是一个Win32 API。对于Java程序，请使用wait/notify（或简单地使用“synchronized”）