Question

我需要使两个线程同步，以便两个线程不能同时运行。一旦被调用，它们需要运行，因此如果另一个线程正在运行，则需要等到另一个线程完成后再运行。我知道我可以使用join（），但是我的问题涉及不同类中的线程，彼此之间没有引用。使线程成为静态类变量以使它们都可以相互访问是一个好主意吗？

从Main Activity中的方法调用一个线程（t1），而另一个线程（t2）在AsyncTask内部：

public class MainActivity extends AppCompatActivity
    {
        public void someMethod()
        {
            // code
            Thread t1 = new Thread(() ->
        {
            // run thread code
        });
        t.start();
        try
            {
            t.join();
            }
        catch (InterruptedException e)
            {
            e.printStackTrace();
            }

            // someMethod follow-up code
        }

    }

    public class FetchData extends AsyncTask<Void, Void, Void>
    {
        protected final Void doInBackground(Void... params)
        {
            // code
            Thread t2 = new Thread(() ->
        {
            // run thread code
        });
        t.start();
        try
            {
            t.join();
            }
        catch (InterruptedException e)
            {
            e.printStackTrace();
            }

            // follow-up code
        }
    }
}

Answer 1

我通过添加静态类线程变量并添加了睡眠因子来执行同步，因此我可以进行测试：

public class MainActivity extends AppCompatActivity implements Interface.InterfaceCommon
    {
    public static Thread t1;
    FetchData fetchData;

    @Override
    protected void onCreate(Bundle savedInstanceState)
        {
        t1 = new Thread();
        fetchData = new FetchData();
        }
    public void someMethod()
        {
        Runnable r = () ->
            {
            try
                {
                Thread.sleep(5000);
                }
            catch (InterruptedException e)
                {
                e.printStackTrace();
                }
            /// Some code
            };
        t1 = new Thread(r);
        try
            {
            FetchData.t2.join();
            t1.start();
            }
        catch (InterruptedException e)
            {
            e.printStackTrace();
            }
        }
    }

    public class FetchData extends AsyncTask<Void, Void, Void>
        {
        public static Thread t2;
        public FetchData()
            {
            t2 = new Thread();
            }
        protected final Void doInBackground(Void... params)
            {
            Runnable r = () ->
                {
                try
                    {
                    Thread.sleep(5000);
                    }
                catch (InterruptedException e)
                    {
                    e.printStackTrace();
                    }
                    /// Some code
                };
            t2 = new Thread(r);
            try
                {
                MainActivity.t1.join();
                t2.start();
                }
            catch (InterruptedException e)
                {
                e.printStackTrace();
                }
            }
        }
    }
}

Answer 2

您可以使用两个阻塞队列，每个线程一个。当他们从队列中读取时，它们将各自开始工作，并通过写入另一个线程的队列而停止。这样，总有一个处于活动状态。他们可以只传递令牌，也可以传递带有数据的对象。

如何同步不同类中的两个线程

2 个答案: