多線程交替輸出1234

阿新 • • 發佈：2018-08-06

ron thread trac rate str throws unlock void except

1、synchronized

package threadT;

public class TestPrint {
    static int i = 1;

    public static void main(String[] args) throws Exception {
        final Object obj = new Object();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                try {
                     
while (true) {
                        synchronized (obj) {
                            Thread.sleep(1000);
                            obj.notifyAll();
                            obj.wait();
                            if (i == 1)
                                System.out.println(i++ % 3);
                        }
                    }
                }  
catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                try {
                    while (true) {
                         
synchronized (obj) {
                            Thread.sleep(1000);
                            obj.notifyAll();
                            obj.wait();
                            if (i == 2)
                                System.out.println(i++ % 3);
                        }
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
        Thread t3 = new Thread(new Runnable() {
            public void run() {
                try {
                    while (true) {
                        synchronized (obj) {
                            Thread.sleep(1000);
                            obj.notifyAll();
                            obj.wait();
                            if (i == 3) {
                                System.out.println(3);
                                i = 1;
                            }
                        }
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
    };
}

2、ReentrantLock

package threadT;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestPrint {
    private static Lock lock = new ReentrantLock();
    private static int state = 0;

    static class First extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                if (state % 4 == 0) {
                    System.out.println("1");
                    state++;
                }
                lock.unlock();
            }
        }
    }

    static class Second extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                if (state % 4 == 1) {
                    System.out.println("2");
                    state++;
                }
                lock.unlock();
            }
        }
    }

    static class Third extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                if (state % 4 == 2) {
                    System.out.println("3");
                    state++;
                }
                lock.unlock();
            }
        }
    }

    static class Forth extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                if (state % 4 == 3) {
                    System.out.println("4");
                    state++;
                }
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        First first = new First();
        Second second = new Second();
        Third third = new Third();
        Forth forth = new Forth();
        first.start();
        second.start();
        third.start();
        forth.start();
    }
}

3、Semaphore

package threadT;

import java.util.concurrent.Semaphore;

public class TestPrint {
    public static Semaphore sem1;
    public static Semaphore sem2;
    public static Semaphore sem3;
    public static Semaphore sem4;

    static class FirstThread extends Thread {
        @Override
        public void run() {
            try {
                while (true) {
                    Thread.sleep(1000);
                    sem1.acquire();
                    System.out.println("1");
                    sem2.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class SecondThread extends Thread {
        @Override
        public void run() {
            try {
                while (true) {
                    Thread.sleep(1000);
                    sem2.acquire();
                    System.out.println("2");
                    sem3.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ThirdThread extends Thread {
        @Override
        public void run() {
            try {
                while (true) {
                    Thread.sleep(1000);
                    sem3.acquire();
                    System.out.println("3");
                    sem4.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ForthThread extends Thread {
        @Override
        public void run() {
            try {
                while (true) {
                    Thread.sleep(1000);
                    sem4.acquire();
                    System.out.println("4");
                    sem1.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        sem1 = new Semaphore(1);
        sem2 = new Semaphore(1);
        sem3 = new Semaphore(1);
        sem4 = new Semaphore(1);
        try {
            // 不要有sem1.acquire()
            sem2.acquire();
            sem3.acquire();
            sem4.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new FirstThread().start();
        new SecondThread().start();
        new ThirdThread().start();
        new ForthThread().start();

    }
}

4、volatile

package threadT;

public class TestPrint {
    volatile static int state = 0;

    static class First extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if (state % 4 == 0) {
                    System.out.println("1");
                    state++;
                }
            }
        }
    }

    static class Second extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if (state % 4 == 1) {
                    System.out.println("2");
                    state++;
                }
            }
        }
    }

    static class Third extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if (state % 4 == 2) {
                    System.out.println("3");
                    state++;
                }
            }
        }
    }

    static class Forth extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if (state % 4 == 3) {
                    System.out.println("4");
                    state++;
                }
            }
        }
    }

    public static void main(String[] args) {
        First first = new First();
        Second second = new Second();
        Third third = new Third();
        Forth forth = new Forth();
        first.start();
        second.start();
        third.start();
        forth.start();
    }
}

多線程交替輸出1234

ron thread trac rate str throws unlock void except 1、synchronized package threadT; public class TestPrint { static int i = 1;

Java多線程，線程交替執行

csdn display runnable start rac 技術分享 over http ++ 兩個線程，一個打印1-100的奇數，一個打印1-100的偶數；要求：線程1打印5個之後，線程2開始打印，線程2打印5個之後，線程1再開始打印，以此循環。 Code:

多線程經典問題2——子線程之間交替問題

line read microsoft star 經典問題推斷 all size lcx 編寫一個程序。開啟3個線程，這3個線程的ID分別為A、B、C，每一個線程將自己的ID在屏幕上打印10遍，要求輸出結果必須按ABC的順序顯示；如：ABCABC….依次遞推。

關於多線程輸出1到一億平方的探討

總結技術如何實現線程池 join 代碼 ima 學習 size 問題：利用多線程的知識輸出打印1到一億平方的結果？問題拆解：1.線程數量較多，考慮線程池來管理 2.主線程監控其他線程，如何實現？（所有線程結束後打印結束時間啊）

C# 多線程、控制線程數提高循環輸出效率

AD gate ... 明顯分享 invoke sca art datetime 原文:C# 多線程、控制線程數提高循環輸出效率 C#多線程及控制線程數量，對for循環輸出效率。雖然輸出不規律，但是效率明顯提高。思路：如果要刪除1000條數據，只

多線程（五）、同步訪問對象，循環打印1234

thread monit object div lse str == art string class Program12 { static object obj = new object(); static int lastNum

多線程按序交替打印

exce stat rri imp num exception abc main trace 一、線程按序交替打印效果展示： A 1 A 2 A 3 A 4 A 5 B 1 B 2 B 3 B 4 B

java多線程（4）模擬排隊叫號程序，不能出現交替執行的結果

pac main program chapter java desc class void sta package com.javaconcurrencyprogramming.chapter1;/** * @description: 模擬有錯誤的排隊叫號程序 * @aut

Java多線程編程模式實戰指南（三）：Two-phase Termination模式

增加 row throws mgr 額外 finally join table 還需停止線程是一個目標簡單而實現卻不那麽簡單的任務。首先，Java沒有提供直接的API用於停止線程。此外，停止線程時還有一些額外的細節需要考慮，如待停止的線程處於阻塞（等待鎖）或者等待狀態（等

ios多線程操作（四）—— GCD核心概念

indent img 操作 fort 16px 2.0 b2c 有一種 read GCD全稱Grand Central Dispatch。可譯為“大派發中樞調度器”，以純C語言寫成，提供了很多很強大的函數。GCD是蘋果公司為多核的並行運算提出的解決方式，它能夠自己主

利刃 MVVMLight 8：DispatchHelper在多線程和調度中的使用

isf ref ping 輔助比例修改 brush ner aac 在應用程序中，線程可以被看做是應用程序的一個較小的執行單位。每個應用程序都至少擁有一個線程，我們稱為主線程，這是在啟動時調用應用程序的主方法時由操作系統分配啟動的線程。當調用和操

基於upd的socketserver,即udp的多線程

rip strip() pri socket send while handle for hand 服務端 #udp服務端多進程import socketserverclass My_server(socketserver.BaseRequestHandler): d

基於tcp的socketserver,即tcp的多線程

握手 for 數據 ket 函數線程 listen utf-8 thread tcp是數據流式的,它的收發信息,是通過管道的.在進行鏈接時,必須雙方同時答應,故有三次握手,四次斷開機制服務端import socketserver #用於進行都並發,即服務端能同時接收多個

JAVA多線程入門

running 關鍵詞處理器關鍵字多線程為什麽使用多線程進程之間不能共享內存，但線程之間共享內存很容易系統創建進程需要為該進程重新分配系統資源，但創建線程代價小得多，因此使用多線程來實現多任務並發比多進程的效率高JAVA內置了多線程功能支持，而不是單純的作為底層操作系統的調度

java基礎之多線程

健壯性等待 block running 調用相同空間獲取行程參考博客 http://www.mamicode.com/info-detail-517008.html 1.進程和線程的區別　　進程：每個進程都有獨立的代碼和數據空間（進程上下文），進程間的切換會有

Java多線程機制

tro wid 機制 bsp 多核 idt http log 任務 Java 中的多線程簡介 1. 並發與並行的區別：　　二者之間的區別在於，並發指的是一個處理器同時處理多個任務，並行指的是多個處理器或者是多核的處理器同時處理多個不同的任務. 2. 並發是邏輯上的同時發生

python 多線程並發threading & 任務隊列Queue

不同 htm doc threading 阻塞子線程 per 出現 bag https://docs.python.org/3.7/library/concurrency.htmlpython程序默認是單線程的，也就是說在前一句語句執行完之前後面的語句不能繼續執行先感受一

java 多線程面試題

obj 高級註意執行本地線程 java 多線程也不會以及 native 0、Java中多線程同步是什麽？在多線程程序下，同步能控制對共享資源的訪問。如果沒有同步，當一個Java線程在修改一個共享變量時，另外一個線程正在使用或者更新同一個變量，這樣容易導致程序出現

Java中的多線程

stat 創建 run ron 實現簡介通過 public main Java 中的多線程簡介 1. Java 中的線程是通過 java.lang.Thread 類來實現的, 每一個 Thread 對象, 代表了一個新的主線程的線程. 2. Java 虛擬機啟動時會有一

多進程與多線程

self 睡眠數據集另一個工作 time 表示 print run 什麽是進程？進程就是一個程序在一個數據集上的一次動態執行過程。進程一般由程序、數據集、進程控制塊三部分組成。我們編寫的程序用來描述進程要完成哪些功能以及如何完成；數據集則是程序在執行過程中所需要使

多線程交替輸出1234

相關推薦