Partagez un exemple de tutoriel sur les bases du multithreading Java

J'ai récemment acheté du café aux fleurs. Les grains provenaient de la machine à café et les fleurs étaient des fleurs d'osmanthus que j'avais achetées lors de mon voyage à Yangshuo la semaine dernière.

Le goût du café est un peu plus léger et il y a plus de parfum d'osmanthus.

Allons droit au but :

Dans cet article, nous étudierons wait() notify() notifyAll() .

DEMO1 : wait() et 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();
    }
}

Sortie DEMO1 :

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

Remarque :

Utilisez wait() et notify () doit être appelé après avoir obtenu le verrou de synchronisation. S'il est appelé directement, une erreur java.lang.IllegalMonitorStateException sera signalée car le state est protégé par le verrou de synchronisation.

wait() est différent de sleep() dans le sens où wait() libérera le verrou de synchronisation.

Parce que wait() et notify() sont implémentés sur la base d'un verrou de synchronisation, chaque objet a son propre verrou de synchronisation, donc wait() et notify() sont des méthodes d'Object, au lieu de Fil de discussion.

DEMO2, wait() et 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();
    }
}

Sortie DEMO2 :

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

La méthode wait() du même objet peut être utilisée plusieurs fois fois dans différents Appelés dans un thread, différents threads peuvent attendre (bloquer). Vous pouvez notify() un par un, ou vous pouvez appeler notifyAll() pour les réveiller tous en même temps.

[Recommandations associées]

1. Explication détaillée des bases du multithread Java

2. À propos de la synchronisation des threads Java

3. Explication détaillée de la synchronisation des threads Java et des méthodes de synchronisation

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!