/**
* 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