/**
* An example of how to create threads by inheriting the {@link Thread} class.
*/
class ThreadInheritance extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
ThreadInheritance threadInheritance1 = new ThreadInheritance();
ThreadInheritance threadInheritance2 = new ThreadInheritance();
ThreadInheritance threadInheritance3 = new ThreadInheritance();
threadInheritance1.start();
threadInheritance2.start();
threadInheritance3.start();
}
}
/**
* An example of how to create threads from the {@link Runnable} interface.
* It's easier than easy — we implement this interface and then pass an instance of our object
* to the constructor.
*/
class ThreadInheritance implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
ThreadInheritance runnable1 = new ThreadInheritance();
ThreadInheritance runnable2 = new ThreadInheritance();
ThreadInheritance runnable3 = new ThreadInheritance();
Thread threadRunnable1 = new Thread(runnable1);
Thread threadRunnable2 = new Thread(runnable2);
Thread threadRunnable3 = new Thread(runnable3);
threadRunnable1.start();
threadRunnable2.start();
threadRunnable3.start();
}
}
class DoubleStartThreadExample extends Thread {
/**
* Simulate the work of a thread
*/
public void run() {
// Something happens. At this state, this is not essential.
}
/**
* Start the thread twice
*/
public static void main(String[] args) {
DoubleStartThreadExample doubleStartThreadExample = new DoubleStartThreadExample();
doubleStartThreadExample.start();
doubleStartThreadExample.start();
}
}
class ThreadCallRunExample extends Thread {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.print(i);
}
}
public static void main(String args[]) {
ThreadCallRunExample runExample1 = new ThreadCallRunExample();
ThreadCallRunExample runExample2 = new ThreadCallRunExample();
// Two ordinary methods will be called in the main thread, one after the other.
runExample1.run();
runExample2.run();
}
}
class SetDaemonAfterStartExample extends Thread {
public void run() {
System.out.println("Working...");
}
public static void main(String[] args) {
SetDaemonAfterStartExample afterStartExample = new SetDaemonAfterStartExample();
afterStartExample.start();
// An exception will be thrown here
afterStartExample.setDaemon(true);
}
}
/**
* A program that shows how to start a shutdown hook thread,
* which will be executed right before the JVM shuts down
*/
class ShutdownHookThreadExample extends Thread {
public void run() {
System.out.println("shutdown hook executed");
}
public static void main(String[] args) {
Runtime.getRuntime().addShutdownHook(new ShutdownHookThreadExample());
System.out.println("Now the program is going to fall asleep. Press Ctrl+C to terminate it.");
try {
Thread.sleep(60000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* An example where we synchronize a method. That is, we add the synchronized keyword to it.
* There are two authors who want to use one printer. Each of them has composed their own poems
* And of course they don’t want their poems mixed up. Instead, they want work to be performed in * * * order for each of them
*/
class Printer {
synchronized void print(List<String> wordsToPrint) {
wordsToPrint.forEach(System.out::print);
System.out.println();
}
public static void main(String args[]) {
// One object for two threads
Printer printer = new Printer();
// Create two threads
Writer1 writer1 = new Writer1(printer);
Writer2 writer2 = new Writer2(printer);
// Start them
writer1.start();
writer2.start();
}
}
/**
* Author No. 1, who writes an original poem.
*/
class Writer1 extends Thread {
Printer printer;
Writer1(Printer printer) {
this.printer = printer;
}
public void run() {
List<string> poem = Arrays.asList("I ", this.getName(), " Write", " A Letter");
printer.print(poem);
}
}
/**
* Author No. 2, who writes an original poem.
*/
class Writer2 extends Thread {
Printer printer;
Writer2(Printer printer) {
this.printer = printer;
}
public void run() {
List<String> poem = Arrays.asList("I Do Not ", this.getName(), " Not Write", " No Letter");
printer.print(poem);
}
}
synchronized ("object to be locked") {
// The code that must be protected
}
為了避免重複前面的示例，我們將使用匿名類創建線程，即我們將立即實現 Runnable 接口。
/**
* This is how a synchronization block is added.
* Inside the block, you need to specify which object's mutex will be acquired.
*/
class Printer {
void print(List<String> wordsToPrint) {
synchronized (this) {
wordsToPrint.forEach(System.out::print);
}
System.out.println();
}
public static void main(String args[]) {
// One object for two threads
Printer printer = new Printer();
// Create two threads
Thread writer1 = new Thread(new Runnable() {
@Override
public void run() {
List<String> poem = Arrays.asList("I ", "Writer1", " Write", " A Letter");
printer.print(poem);
}
});
Thread writer2 = new Thread(new Runnable() {
@Override
public void run() {
List<String> poem = Arrays.asList("I Do Not ", "Writer2", " Not Write", " No Letter");
printer.print(poem);
}
});
// Start them
writer1.start();
writer2.start();
}
}
}
/**
* This is how a synchronization block is added.
* Inside the block, you need to specify which object's mutex will be acquired.
*/
class Printer {
static synchronized void print(List<String> wordsToPrint) {
wordsToPrint.forEach(System.out::print);
System.out.println();
}
public static void main(String args[]) {
// Create two threads
Thread writer1 = new Thread(new Runnable() {
@Override
public void run() {
List<String> poem = Arrays.asList("I ", "Writer1", " Write", " A Letter");
Printer.print(poem);
}
});
Thread writer2 = new Thread(new Runnable() {
@Override
public void run() {
List<String> poem = Arrays.asList("I Do Not ", "Writer2", " Not Write", " No Letter");
Printer.print(poem);
}
});
// Start them
writer1.start();
writer2.start();
}
}
如果現實生活中的比賽涉及汽車，那麼多線程中的比賽就涉及線程。但為什麼？:/ 有兩個線程正在運行並且可以訪問同一個對象。他們可能會同時嘗試更新共享對象的狀態。到目前為止一切都很清楚，對吧？線程要么按字面意義並行執行（如果處理器有多個內核），要么按順序執行，處理器分配交錯的時間片。我們無法管理這些流程。這意味著當一個線程從一個對象讀取數據時，我們不能保證它有時間在其他線程這樣做之前更改對象。當我們有這些“檢查和行動”組合時，就會出現這樣的問題。這意味著什麼？假設我們有一個if語句，它的主體改變了 if 條件本身，例如：
int z = 0;
// Check
if (z < 5) {
// Act
z = z + 5;
}
當 z 仍然為零時，兩個線程可以同時進入這個代碼塊，然後兩個線程都可以更改它的值。結果，我們不會得到預期值 5。相反，我們會得到 10。如何避免這種情況？您需要在檢查和操作之前獲取鎖，然後再釋放鎖。也就是說，您需要讓第一個線程進入if塊，執行所有操作，更改z，然後才給下一個線程執行相同操作的機會。但是下一個線程不會進入if塊，因為z現在是 5：
// Acquire the lock for z
if (z < 5) {
z = z + 5;
}
// Release z's lock
===================================================
進程和線程在以下方面有所不同：
讓我們考慮一個例子，它有一個實現 Runnable 的類。它的構造函數需要兩個資源。run() 方法按順序為它們獲取鎖。如果你創建了這個類的兩個對象，並以不同的順序傳遞資源，那麼你很容易陷入死鎖：
GO TO FULL VERSION