Apakah operasi benang Java yang biasa digunakan?

Operasi biasa rangkaian

Tetapkan nama utas: setName()

Dapatkan nama utas: getName()

ID unik utas: getId()

// 自定义线程名称
String threadName = "threadName";
// 构造方法方式
Thread thread = new Thread(() -> {
    System.out.println("线程名=" + Thread.currentThread().getName());
},threadName);
// set方法方式
// thread.setName(threadName);
System.out.println("线程唯一Id=" + thread.getId());

Permulaan utas: start()

Nilai sama ada utas itu hidup: isAlive()

// 线程启动
thread.start();
System.out.println("是否为存活线程=" + thread.isAlive());

Kaedah utas: run() /call()

Kaedah yang akan dipanggil selepas thread dimulakan. Perkara yang ingin dilakukan oleh utas adalah ditulis dalam kaedah run/call. Tidak perlu memanggilnya secara langsung Selepas utas dimulakan, ia akan memanggil run()/call(). Jika program memanggil run/call terus tanpa memulakan thread, maka ia bukan milik pengaturcaraan berbilang benang, tetapi ia tergolong dalam thread semasa untuk memanggil terus kaedah biasa.

Dapatkan objek utas semasa: currentThread()

Untuk mengendalikan kaedah bukan statik benang semasa, anda mesti mendapatkan objek utas dahulu.

// 获取当前线程对象
Thread currentThread = Thread.currentThread();
// 对当前线程做一些操作
System.out.println(currentThread.getName());
try {
    // sleep 静态方法则不需要
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

Mengenai operasi kawalan status benang (Kitaran hayat) boleh merujuk kepada artikel sebelumnya.

Benang Daemon (benang latar belakang)

Penjaga benang biasa (benang pengguna) Tugas benang daemon adalah untuk menyediakan perkhidmatan untuk benang lain. Jika tiada benang pengguna dalam proses, maka benang daemon tidak mempunyai makna, dan JVM juga akan berakhir. Benang daemon biasa termasuk benang kutipan sampah JVM, dan permulaan sistem pengendalian juga akan memulakan benang daemon pelbagai modul.

Tetapkan benang sebagai benang daemon: setDaeman()

Nota: Kaedah ini mesti dipanggil sebelum kaedah mula()

public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        System.out.println("线程名="+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 这一句不会打印出来，因为main线程（目前唯一的普通线程）等待1秒后已经结束了
        System.out.println("守护线程的状态=" + Thread.currentThread().getState());
    });
    // 守护线程
    thread.setDaemon(true);
    // 线程启动
    thread.start();
    System.out.println("是否为守护线程=" + thread.isDaemon());
}

Penyirian benang

Benang yang melaksanakan kaedah join() memasuki Keadaan menunggu (MENUNGGU) sehingga benang yang dipanggil kaedah tamat dan kemudian berubah daripada keadaan menunggu kepada keadaan boleh dijalankan (BOLEH LARI). Kaedah join() ialah kaedah dalam kelas Thread Kaedah asasnya ialah menggunakan kaedah wait() untuk merealisasikan thread waiting () Apabila thread isAlive() is false, serialization of the thread is

dilaksanakan: satu benang memanggil Join() lain objek benang untuk melaksanakan pelaksanaan bersiri benang.

Contohnya: hidangan yang bagus

public class DemoCooking {
    
    public static void main(String[] args) {
        Thread mainThread = Thread.currentThread();
        // 1.买菜
        Thread buyThread = new Thread(new CookingThread(mainThread,"买菜"),"buyThread");
        // 2.洗菜
        Thread washThread = new Thread(new CookingThread(buyThread,"洗菜"),"washThread");
        // 3.切菜
        Thread cutThread = new Thread(new CookingThread(washThread,"切菜"),"cutThread");
        // 4.炒菜
        Thread scrambleThread = new Thread(new CookingThread(cutThread,"炒菜"),"scrambleThread");

        // 不受线程启动顺序的影响
        scrambleThread.start();
        washThread.start();
        cutThread.start();
        buyThread.start();
        
        // main线程先执行完才可以开始：买菜
        System.out.println("开始准备……");
    }

    public static class CookingThread implements Runnable{
        private final Thread thread;
        private final String job;

        public CookingThread(Thread thread, String job){
            this.thread = thread;
            this.job = job;
        }
        @Override
        public void run() {
            String name = Thread.currentThread().getName()+"：";
            try {
                thread.join();

                System.out.println(name + job + "开始");
                Thread.sleep(1000);
                System.out.println(name + job + "结束");
                Thread.sleep(1000); // 偷懒下
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Hasil pelaksanaan: utama > buyThread > cutThread > menyediakan...

beliBenang: mula membeli-belah sayur

beliBenar: tamat membeli-belah sayur

mencuciBenang: mula membasuh sayur
mencuciBenang: selesai membasuh sayur
memotongBenang: mula memotong sayur
memotong Benang :Cincang tamat
ScrambleThread: Tumis bermula
scrambleThread: Tumis tamat


Thread priority

Tetapkan keutamaan thread semasa keutamaan, lebih tinggi keutamaan utas Semakin banyak kali boleh dilaksanakan, keutamaan utas Java diwakili oleh integer Julat keutamaan ialah 1-10, dan lalai ialah 5.

kaedah setPriority(int): Tetapkan keutamaan utas.

kaedah getPriority: Dapatkan keutamaan utas.

Gangguan Benang

public static void main(String[] args) {

    Thread thread = new Thread(() -> {
        System.out.println("线程1");
    });
    thread.setPriority(10);
    Thread thread1 = new Thread(() -> {
        System.out.println("线程2");
    });
    thread1.setPriority(1);
    thread.start();
    thread1.start();

    System.out.println("线程默认的优先级为=" + Thread.currentThread().getPriority());

}

Gunakan kaedah interrupt() untuk menetapkan bendera gangguan benang = benar, supaya isyarat gangguan dilemparkan apabila benang "disekat". Jika urutan disekat, menunggu untuk bangun atau keadaan menunggu tamat masa (Object.wait, Thread.join dan Thread.sleep), maka ia akan menerima pengecualian gangguan (InterruptedException) dan menamatkan keadaan lebih awal. Sebaliknya, jika benang berada dalam keadaan "BOLEH RUNNABLE", bendera gangguan tidak akan memberi kesan.

Kes 1: Gangguan benang adalah sah

Hasil pelaksanaan:

public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        System.out.println("线程1");
        try {
            // 闹钟1分钟后响
            Thread.sleep(60000);
            System.out.println("闹钟响了");
        } catch (InterruptedException e) {
            // 提前退出超时等待状态
            System.out.println("发生异常，提前醒了，闹钟没响手动关了");
        }

        System.out.println("继续执行该线程的后续程序……");

    });
    thread.setPriority(1);
    thread.start();
    thread.interrupt();
    System.out.println("main线程将thread 终端状态设置为 "+thread.isInterrupted());
}

benang utama menetapkan status terminal benang kepada benar

Benang 1

Pengecualian berlaku, saya bangun awal, penggera tidak berbunyi dan saya mematikannya secara manual

Teruskan untuk melaksanakan program urutan seterusnya...


Kes 2: Gangguan benang adalah tidak sah

Hasil pelaksanaan: Benang sentiasa mencetak statusnya sebagai RUNNABLE.

Atas ialah kandungan terperinci Apakah operasi benang Java yang biasa digunakan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!