Teilen Sie ein Beispiel-Tutorial zu den Grundlagen des Java-Multithreadings

Ich habe kürzlich Blumenkaffee gekauft, den ich mit der Kaffeemaschine geliefert habe, und die Blumen, die ich letzte Woche während meiner Reise nach Yangshuo gekauft habe.

Der Kaffeegeschmack ist etwas leichter und es duftet mehr nach Osmanthus.

Um es auf den Punkt zu bringen:

In diesem Artikel werden wir uns mit wait() notify() notifyAll() befassen.

DEMO1: wait() und notify()

public class Test {

    static class ThreadOne extends Thread {

        private Callback mCallback;

        @Override
        public void run() {
            work();
            if (mCallback != null) {
                mCallback.onResult(false);
            }
        }

        // 耗时 3s
        private void work() {
            System.out.println(" 正在查询数据库 1");
            long startTime = System.currentTimeMillis();
            while (true) {
                if (System.currentTimeMillis() - startTime < 3000) {
                    continue;
                }
                break;
            }
        }

        public void setCallback(Callback callback) {
            mCallback = callback;
        }

        public interface Callback {
            void onResult(boolean result);
        }
    }

    static class ThreadTest extends Thread {

        private Object mLock = new Object();

        private ThreadOne mThreadOne;

        @Override
        public void run() {
            workOne();
            System.out.println(" 根据结果继续做其他事情 ");
        }

        private void workOne() {
            mThreadOne = new ThreadOne();
            mThreadOne.setCallback(new ThreadOne.Callback() {
                @Override
                public void onResult(boolean result) {
                    System.out.println(" 查询数据库 1 结束，:" + (result ? " 有数据 " : " 无数据 "));
                    synchronized (mLock) {
                        mLock.notify();
                        System.out.println("--ThreadTest 结束等待 --");
                    }
                }
            });
            mThreadOne.start();
            try {
                synchronized (mLock) {
                    System.out.println("--ThreadTest 进入等待 --");
                    mLock.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] var0) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
}

DEMO1-Ausgabe:

--ThreadTest 进入等待--
正在查询数据库 1
查询数据库 1 结束，: 无数据
--ThreadTest 结束等待--
根据结果继续做其他事情

Hinweis:

Verwenden Sie wait() und notify () muss nach Erhalt der Synchronisationssperre aufgerufen werden. Bei einem direkten Aufruf wird ein java.lang.IllegalMonitorStateException-Fehler gemeldet, da der state durch die Synchronisationssperre geschützt ist.

wait() unterscheidet sich von sleep() darin, dass wait() die Synchronisationssperre aufhebt.

Da wait() und notify() auf der Grundlage einer Synchronisationssperre implementiert werden, verfügt jedes Objekt über eine eigene Synchronisationssperre, sodass wait() und notify() Methoden von Object sind Faden.

DEMO2, wait() und notifyAll():

public class Test {

    private static Object mLock = new Object();

    static class MyThread extends Thread {

        String mName;
        Callback mCallback;

        public MyThread(String name){
            mName = name;
        }

        @Override
        public void run() {
            work();
            if (mCallback != null) {
                mCallback.onResult(false);
            }
        }

        // 耗时 3s
        private void work() {
            System.out.println(mName + " 等待 ");
            try {
                synchronized (mLock) {
                    mLock.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public void setCallback(Callback callback) {
            mCallback = callback;
        }

        public interface Callback {
            void onResult(boolean result);
        }
    }

    static class ThreadTest extends Thread {



        @Override
        public void run() {
            work("db1");
            work("db2");
            work("db3");

            try {
                sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (mLock) {
                System.out.println(" 唤醒全部 ");
                mLock.notifyAll();
            }
        }

        private void work(String name) {
            final MyThread myThread = new MyThread(name);
            myThread.setCallback(new MyThread.Callback() {
                @Override
                public void onResult(boolean result) {
                    System.out.println(myThread.mName + " 回来了 ");
                }
            });
            myThread.start();
        }
    }

    public static void main(String[] var0) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
}

DEMO2-Ausgabe:

db1 等待
db3 等待
db2 等待
唤醒全部
db3 回来了
db1 回来了
db2 回来了

Die Methode wait() desselben Objekts kann mehrfach verwendet werden Mal in einem Thread aufgerufen, können verschiedene Threads nacheinander warten (blockieren), oder Sie können notifyAll() aufrufen, um sie alle gleichzeitig aufzuwecken.

[Verwandte Empfehlungen]

1. Detaillierte Erläuterung der Java-Multithreading-Grundlagen

2. Informationen zur Java-Thread-Synchronisierung

3. Detaillierte Erläuterung der Java-Thread-Synchronisierung und der Synchronisierungsmethoden

Das obige ist der detaillierte Inhalt vonTeilen Sie ein Beispiel-Tutorial zu den Grundlagen des Java-Multithreadings. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!