Java - multithreading notes

Posted by kaveman50 on Sat, 22 Jan 2022 09:02:14 +0100

Basic concepts of operating system (Master)

example:

The program keeps outputting a greeting on the screen(Like "hello")
"At the same time, when I input fixed input through the keyboard, the program stops outputting greetings to the screen(For example, input gun)

Single thread

package com.cskaoyan._01introduction;

import java.util.Scanner;
import java.util.concurrent.TimeUnit;

/**
 * @description:
 **/

/*
The program keeps outputting a greeting sentence (such as "hello") on the screen
"At the same time, "when I input fixed input through the keyboard, the program stops outputting greetings to the screen (for example, entering gun)

 */
public class Demo {
    public static boolean flag = true;
    public static void main(String[] args) {
        System.out.println("say hello before");
        sayHelloRecycling();
        System.out.println("say hello after");

        System.out.println("wait stop before");
        waitToStop();
        System.out.println("wait stop after");

    }

    private static void waitToStop() {
        Scanner scanner = new Scanner(System.in);
        while (flag) {
            String s = scanner.nextLine();
            if ("gun".equals(s)) {
                flag = false;
                break;
            }
        }
    }

    private static void sayHelloRecycling() {
        while (flag) {
            System.out.println("are you there?");
            // Pause
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

Multithreading

package com.cskaoyan._01introduction;

import java.util.Scanner;
import java.util.concurrent.TimeUnit;

/**
 * @description:
 **/

/*
The program keeps outputting a greeting sentence (such as "hello") on the screen
"At the same time, "when I input fixed input through the keyboard, the program stops outputting greetings to the screen (for example, entering gun)

 */
public class Demo2 {
    public static boolean flag = true;
    public static void main(String[] args) {
        System.out.println("say hello before");
        sayHelloRecycling();
        System.out.println("say hello after");

        System.out.println("wait stop before");
        waitToStop();
        System.out.println("wait stop after");

    }

    private static void waitToStop() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Scanner scanner = new Scanner(System.in);
                while (flag) {
                    String s = scanner.nextLine();
                    if ("gun".equals(s)) {
                        flag = false;
                        break;
                    }
                }
            }
        }).start();

    }

    private static void sayHelloRecycling() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag) {
                    System.out.println("are you there?");
                    // Pause
                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();


    }

}

process

  • The running activity of a computer program on a data set Process is the basic unit of resource scheduling and allocation in operating system
  • Simple understanding: a running program or software

thread

  • There can be multiple subtasks in a process, and each subtask is a thread From the perspective of execution strength, a thread is an execution path Thread is the basic unit of CPU resource scheduling and allocation
  • Thunder download movie

What is the relationship between process and thread

  • Threads are process dependent
  • A process can have multiple threads
  • Threads share resources for processes

serial

  • One task after another is executed in sequence

parallel

  • At the same time point, multiple tasks are executed simultaneously

Concurrent

  • Multiple tasks are executed simultaneously in the same time period

java program operation principle (Master)

Principle of java + main class name

  • The java command will create a jvm process
  • The jvm process will create a thread, and the main thread is main
  • Execute the main method in the main thread

Is the jvm single threaded or multi-threaded

The jvm is multithreaded

  • There is 1 main thread
  • There is also a garbage collection thread

Implementation mode 1 of multithreading: inherit Thread class (key)

A thread is an execution thread in a program. The Java virtual machine allows applications to run multiple execution threads concurrently

Document example

step

  1. Define a class and inherit the Thread class
  2. Override run method
  3. Create subclass objects
  4. start()
package com.cskaoyan._02implone;

/**
 * @description:
 * @author: Sedum
 * @date: 2022/1/20 10:25
 **/
/*
1. Define a class that inherits the Thread class
2. Override run method
3. Create subclass objects
4. start()
 */
public class Demo1 {
    public static void main(String[] args) {
        // 3. Create subclass objects
        MyThread myThread = new MyThread();
        // 4. start()
        myThread.start();
    }
}

//1. Define a class and inherit the Thread class
class MyThread extends Thread{
    //2. Rewrite the run method

    @Override
    public void run() {
        System.out.println("The child thread executed!!!");
    }
}

matters needing attention

  • Executive characteristics

    • Randomness

    • package com.cskaoyan._02implone;
      
      /**
       * @description:
       **/
      /*
      1. Define a class that inherits the Thread class
      2. Override run method
      3. Create subclass objects
      4. start()
       */
      public class Demo2 {
          public static void main(String[] args) {
              // 3. Create subclass objects
              MyThread2 myThread = new MyThread2();
              MyThread2 myThread2 = new MyThread2();
              // 4. start()
              myThread.start();
              myThread2.start();
          }
      }
      
      //1. Define a class and inherit the Thread class
      class MyThread2 extends Thread{
          //2. Rewrite the run method
      
          @Override
          public void run() {
              for (int i = 0; i < 1000; i++) {
                  System.out.println(i);
              }
          }
      }
      
  • What is the difference between the run method and the start method

    • Direct call run Method execution results
      before
      0
      1
      2
      3
      4
      5
      6
      7
      8
      9
      after
      
      use start Method execution results
      before
      after
      0
      1
      2
      3
      4
      5
      6
      7
      8
      9
      
    • The run method does not open up a new execution path at all, but executes in sequence

    • Directly calling the run method is equivalent to calling ordinary member methods

    • The start method is the real way to create a thread

    • Only the code in the run method will be executed in the sub thread. We need to write our code into the run method, and it must be the start method when starting

    • Other methods are used in the run method

  • Can the same thread be started multiple times?

    • No Java Lang.illegalthreadstateexception an exception will be reported if the same thread is started multiple times
  • Who represents a real thread?

    • Only the objects of Thread class and its subclasses represent a Thread

Set / get thread name

StringgetName() returns the name of the thread
voidsetName(String name) changes the thread name to be the same as the parameter name.
Thread(String name) assigns a new thread object. The thread name can also be set through the construction method

The default name of the Thread the Thread number

Gets the name of the main thread

static ThreadcurrentThread() returns a reference to the thread object currently executing
package com.cskaoyan._02implone;

/**
 * @description: Set get thread name
 **/

public class Demo4 {
    public static void main(String[] args) {
        // Gets the name of the main thread
        Thread thread = Thread.currentThread();
        System.out.println("Main thread name = " + thread.getName());
        // Create subclass objects
        MyThread5 t1 = new MyThread5();
        MyThread5 t2 = new MyThread5();
        // Set thread name
        // setName(String name)
        t1.setName("Wang Dao Peng Yuyan");
        t2.setName("Wang Dao Wu Yanzu");
        // The start method starts
        t1.start();
        t2.start();
    }
}

// Inherit Thread class
class MyThread5 extends Thread{
    // run method override

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"------"+i);
        }
    }
}

Thread scheduling (Master)

What is thread scheduling?

The process by which the system allocates CPU resources to threads

classification

  • Collaborative thread scheduling
    • The execution time of the thread is determined by the thread itself. The thread completes its own work, reports to the system, and switches to other threads
  • Preemptive thread scheduling
    • The execution time of a thread is not determined by the thread, but by the system Whoever gets it will execute it

What scheduling method is used in java?

Preemptive thread scheduling

Thread priority (understand)

Operating system thread priority

  • Static priority fixed value
  • Dynamic priority: the priority of executing threads will decrease with the extension of execution time At the same time, the priority of the waiting thread will increase with the extension of the waiting time
  • Static priority + dynamic priority

Thread priority in java

static intMAX_PRIORITY is the highest priority a thread can have. ten
static intMIN_PRIORITY is the lowest priority a thread can have. one
static intNORM_PRIORITY is the default priority assigned to the thread. five

Set get thread priority

intgetPriority() returns the priority of the thread.
voidsetPriority(int newPriority) changes the priority of the thread.
package com.cskaoyan._02implone;

/**
 * @description: thread priority 
 **/

public class Demo5 {
    public static void main(String[] args) {
        // Create subclass objects
        MyThread6 t = new MyThread6();

        // | static int | MAX_PRIORITY is the highest priority a thread can have. 10  |
        //| static int | MIN_PRIORITY is the lowest priority a thread can have. 1 |
        //| static int | NORM_PRIORITY is the default priority assigned to the thread. 5   |

        //setPriority(int pri)
        t.setPriority(Thread.MAX_PRIORITY);

        // Get thread priority
        int priority = t.getPriority();
        System.out.println("priority = " + priority);
        // The start method starts

        t.start();
    }
}

class MyThread6 extends Thread{

    // run

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}

Is priority in java useful?

practice:

Requirements:

Create 2 threads, both of which print 10

One thread has the highest priority and the other thread has the lowest priority

start-up

Normal logic analysis: high priority is executed first, and low priority is executed later The number of high priority 10 shall be printed first, and the low priority shall be printed again

Conclusion:

The results of the implementation did not meet our expectations

reason:

The priority in java is only a static priority, just a "suggestion" to the operating system

Operating system: dynamic + static

java official: Thread priority is not completely useless. We use Thread priority, which has statistical significance. Generally speaking, high priority threads
The cpu execution time occupied is a little more. Low priority threads occupy a little less cpu execution time

package com.cskaoyan._02implone;

/**
 * @description: java Is the priority in useful
 **/
/*
Requirements:

Create 2 threads, both of which print 10

1 One thread has the highest priority and the other thread has the lowest priority

start-up

Normal logic analysis: high priority is executed first, and low priority is executed later The number of high priority 10 shall be printed first, and the low priority shall be printed again
 */
public class Demo6 {
    public static void main(String[] args) {
        // Create 2 Thread objects
        MyThread7 t1 = new MyThread7();
        MyThread7 t2 = new MyThread7();
        t1.setName("cattle x");
        t2.setName("Little garbage");
        // Set priority 1 10 1 1
        t1.setPriority(10);
        t2.setPriority(Thread.MIN_PRIORITY);
        // The start method starts
        t1.start();
        t2.start();
    }
}

// Define class inheritance Thread
class MyThread7 extends Thread{

    // Override run method

    @Override
    public void run() {
        // Number of prints in the run method
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"------"+i);
        }
    }


}


Thread control API (Master)

Thread sleep

static voidsleep(long millis) sleeps (pauses) the currently executing thread within a specified number of milliseconds. This operation is affected by the accuracy and accuracy of the system timer and scheduler
package com.cskaoyan._03api;

import java.util.concurrent.TimeUnit;

/**
 * @description: Thread sleep
 **/

public class SleepDemo {
    public static void main(String[] args) {
        System.out.println("1");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("2");

        // Create subclass objects
        ThreadSleep threadSleep = new ThreadSleep();
        // start
        threadSleep.start();
    }
}

class ThreadSleep extends Thread{
    // run

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            try {
                // Let the program block (wait)
                Thread.sleep(2000);
                //TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Thread join

voidjoin() waits for the thread to terminate
Not used join Previous results:
main start
main------0
main------1
main------2
main end
Thread-0------0
Thread-0------1
Thread-0------2
Thread-0------3
Thread-0------4
Thread-0------5
Thread-0------6
Thread-0------7
Thread-0------8
Thread-0------9



use join result:
main start
Thread-0------0
Thread-0------1
Thread-0------2
Thread-0------3
Thread-0------4
Thread-0------5
Thread-0------6
Thread-0------7
Thread-0------8
Thread-0------9
main------0
main------1
main------2
main end

Waiting for who?

Waiting is a child thread The waiting thread should be the thread calling the join method

Who is waiting?

The main thread is waiting The line of code executing the join runs on which thread, and that thread waits

package com.cskaoyan._03api;

/**
 * @description: Thread join
 **/

public class JoinDemo {
    public static void main(String[] args) {
        System.out.println("main start");

        // Create subclass objects
        ThreadJoin threadJoin = new ThreadJoin();
        // start
        threadJoin.start();
        // join()
        try {
            threadJoin.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "------" + i);
        }

        System.out.println("main end");
    }
}


class ThreadJoin extends Thread{
    // run

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"------"+i);
        }
    }
}

Thread yield

static voidyield() pauses the currently executing thread object and executes other threads.

practice:

Create 2 Thread objects and print 10 numbers respectively

A thread print 1, B thread print 1,A thread print 2, B thread print 2

Conclusion:

It can't be done through yield

Reason: Although the current thread gives up the execution right of the CPU, it still participates in the next round of CPU competition Who grabs and who executes

package com.cskaoyan._03api;

/**
 * @description: Thread comity
 **/

/*
Create 2 Thread objects and print 10 numbers respectively

A Thread printing 1, thread B printing 1, thread a printing 2, thread B printing 2
 */
public class YieldDemo {
    public static void main(String[] args) {
        // Create 2 Thread objects
        ThreadYield t1 = new ThreadYield();
        ThreadYield t2 = new ThreadYield();
        t1.setName("A");
        t2.setName("B");
        // start
        t1.start();
        t2.start();
    }
}


class ThreadYield extends Thread{
    // run

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "-----" + i);
            // Execute yield method
            // Pauses the currently executing thread object and executes other threads (including himself)
            Thread.yield();
            // java uses preemptive thread scheduling
        }
    }
}

daemon thread

voidsetDaemon(boolean on) marks the thread as a daemon or user thread.

Thread classification:

  • User thread
  • Daemon thread

be careful

  • When all running threads are daemon threads, the Java virtual machine exits.
  • This method must be called before the thread is started. (start) java. Lang. illegalthreadstateexception (exception will be reported after start)
package com.cskaoyan._03api;

/**
 * @description: Daemon thread
 **/

public class DaemonDemo {
    public static void main(String[] args) {
        // Create thread object
        ThreadDaemon t = new ThreadDaemon();

        // setDaemon(boolean on)
        // Mark the thread as a daemon or user thread.
        // Set the child thread as a daemon

        // start
        t.start();
        t.setDaemon(true);

        // Print 3 numbers in main, and sleep for 1s for each print
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "----" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

class ThreadDaemon extends Thread{
    //run

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            // Sleep for 1s per print
            System.out.println(getName() + " -------" + i);
            // sleep
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Thread interrupt/stop

voidinterrupt() interrupts the thread. If a thread is blocked in calling the wait(), wait(long) or wait(long, int) methods of the Object class, or the join(), join(long), join(long, int), sleep(long) or sleep(long, int) methods of the class, its interrupt state will be cleared and it will receive an InterruptedException.
stop() this method is inherently unsafe
package com.cskaoyan._03api;

/**
 * @description: Interrupt thread
 **/

public class InterruptDemo {
    public static void main(String[] args) {
        // Create subclass objects
        ThreadInterrupt t = new ThreadInterrupt();
        // The start method starts
        t.start();

        // Mainprint 3 numbers
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "----" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // Execute interrupt()
        // An exception will be generated through the exception handling mechanism
        //t.interrupt();
        // stop unsafe
        t.stop();

    }
}

class ThreadInterrupt extends Thread{

    // run

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"-----"+i);
            // Sleep for 1s per print
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();

            }
            // Suppose this is an operation on the database
        }
    }
}

Supplementary safe termination thread

practice:

Create a sub thread. 10 sub threads are required to be printed. Each time one sub thread is printed, it will sleep for one second

The number of prints in the main thread is 3. Every time one print is dormant for 1s, it is required to terminate the thread

Use the boolean flag, which is true by default and set to false to interrupt the thread

At this time, the sub thread requires to save the interrupt information to the log file log txt

Format: 2022-01-20 16:06:00 interrupt occurred

package com.cskaoyan._03api;

import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @description: Safe thread termination
 **/

/*
Create a sub thread. 10 sub threads are required to be printed. Each time one sub thread is printed, it will sleep for one second

main The number of prints in the thread is 3. Every time one print is dormant for 1s, it is required to terminate the thread

Use the boolean flag, which defaults to true and is set to false to interrupt the thread

At this time, the sub thread requires that the interrupt information be saved to the log file log txt

Format: 2022-01-20 16:06:00 interrupt occurred
 */
public class StopSecurity {
    public static void main(String[] args) {
        // Create thread object
        ThreadStop t = new ThreadStop();
        // start
        t.start();
        // Print 3 numbers in main thread, and sleep for 1s for each print
        for (int i = 0; i < 3; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // Interrupt the thread and change the value of flag
        t.flag = false;


    }
}

class ThreadStop extends Thread{
    // Define member variables
    boolean flag = true;

    //run

    @Override
    public void run() {
        // It is required to print 10 sub threads, and sleep for one s for each print
        for (int i = 0; i < 10; i++) {
            // Judge
            // If true, print normally
            if (flag) {
                System.out.println(getName() + "-----" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                // If false, the interrupt information is saved to the file
                // At this time, the sub thread requires that the interrupt information be saved to the log file log txt
                // Create a FIleWriter object
                FileWriter fileWriter = null;
                try {
                    fileWriter = new FileWriter("log.txt");
                    //Format: 2022-01-20 16:06:00 interrupt occurred
                    // Specify format
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String date = sdf.format(new Date());
                    // write
                    fileWriter.write(date + getName()+" An interrupt has occurred!");
                    // flush
                    fileWriter.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    // close
                    if (fileWriter != null) {
                        try {
                            fileWriter.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }

            }


        }
    }
}

Thread life cycle (focus)

Five states of threads

newly build

  • new thread object

be ready

  • After the start method is started, wait for the CPU to execute

implement

  • Grabbed the execution power of the CPU

block

  • In addition to not having the execution authority of the CPU, there are also some necessary resources, such as sleep and join

death

  • The run method has finished executing

Transitions between states

Multithreading implementation mode 2: implement Runnable interface (key)

Document example

step

  1. Implement Runnable interface
  2. Override run method
  3. Create a subclass object that implements the Runnable interface
  4. Create Thread objects and Thread objects, and pass subclass objects as parameters
  5. The start method starts
package com.cskaoyan._04impltwo;

/**
 * @description: Implementation mode 2 of multithreading
 **/

/*
1. Implement Runnable interface
2. Override run method
3. Create a subclass object that implements the Runnable interface
4. Create Thread objects and Thread objects, and pass subclass objects as parameters
5. start Method start
 */
public class Demo {
    public static void main(String[] args) {
        //3. Create a subclass object that implements the Runnable interface
        MyRunnable myRunnable = new MyRunnable();
        //4. Create Thread objects and Thread objects, and pass subclass objects as parameters
        Thread thread = new Thread(myRunnable);
        //5. start method
        thread.start();
    }
}

// 1. Implement Runnable interface

class MyRunnable implements Runnable{
//2. Rewrite the run method
    @Override
    public void run() {
        System.out.println("The child thread executed!!");
    }
}

Why does the run method in Runnable run in a child thread?

class Thread {
    // Define member variables
    private Runnable target;
    
    init(){
        //...
        // On the left is the member variable, and on the right is the parameter we passed
        this.target = target
        
    }
    
    void run(){
        if(target != null){
            target.run()
        }
    }
    
    
}

Mode 1 VS mode 2

  • Step angle: 4 steps for mode 1 and 5 steps for mode 2
  • The first way is through inheritance, which has the limitation of single inheritance
  • The second way is to implement the interface, which can still be inherited
  • Mode 2 distinguishes the execution path from what needs to be done on the execution path (decoupling)
  • Mode 2 is more convenient for data sharing

The multithreading simulation scenario is as follows:
Suppose A movie is showing in cinema A, and there are 100 movie tickets for sale. Now suppose there are 3 windows for ticket sales. Please design A program to simulate the scene of window ticket selling.

analysis:
Ticket sales at three windows are carried out at the same time without affecting each other. Multithreading 3 threads
Three windows sell the 100 movie tickets together, and three threads share the 100 tickets

Mode 1:

package com.cskaoyan._05datasecurity;

/**
 * @description:
 **/

/*
analysis:
3 Tickets are sold at two windows at the same time without affecting each other. Multithreading 3 threads
3 Three windows sell the 100 movie tickets together, and three threads share the 100 tickets
 */
public class Demo {
    public static void main(String[] args) {
        // Create 3 threads
        SellWindow t1 = new SellWindow();
        SellWindow t2 = new SellWindow();
        SellWindow t3 = new SellWindow();
        t1.setName("A window");
        t2.setName("B window");
        t3.setName("C window");
        // start
        t1.start();
        t2.start();
        t3.start();
    }
}

class SellWindow extends Thread{
    // Member variable
    static int tickets = 100;

    // run
    @Override
    public void run() {
        while (true) {
            // Simulated ticket selling
            // judge
            if (tickets > 0) {
                // Increase network delay
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(getName()+"Sold the second"+ (tickets--) + "ticket");
            }
        }
    }
}

Mode 2:

package com.cskaoyan._05datasecurity;

/**
 * @description:
 **/

/*
analysis:
3 Tickets are sold at two windows at the same time without affecting each other. Multithreading 3 threads
3 Three windows sell the 100 movie tickets together, and three threads share the 100 tickets
 */
public class Demo2 {
    public static void main(String[] args) {
        // Create subclass objects
        SellWindow2 sellWindow2 = new SellWindow2();

        // Create 3 threads
        Thread t1 = new Thread(sellWindow2);
        Thread t2 = new Thread(sellWindow2);
        Thread t3 = new Thread(sellWindow2);
        t1.setName("A window");
        t2.setName("B window");
        t3.setName("C window");
        // start
        t1.start();
        t2.start();
        t3.start();
    }
}

class SellWindow2 implements Runnable{
    // Member variable
    int tickets = 100;

    // run
    @Override
    public void run() {
        while (true) {
            // Simulated ticket selling
            // judge
            // Analysis: Why are there duplicate tickets
            // Assuming that tickets = 100, A grabs the execution right of the CPU
            // Suppose B grabs the execution right of the CPU
            if (tickets > 0) {
                try {
                    // At this time, A goes to sleep
                    // At this time, B went to sleep
                    // At this time, c went to sleep

                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+
                        "Sold the second"+ (tickets--) + "ticket");

                // tickets -- three steps
                // 1. Value 2- 1  3.  Reassign
                // Suppose A takes the value of 100
                // B execution value 100
                // c execution value 100
            }
        }
    }
}

There are two situations:

  • Non existent ticket
  • Duplicate ticket

Causes of multithreaded data security problems (Master)

Solve the problem of multithreaded data security (key)

synchronized

Synchronous code block

Synchronization method

Static method

lock

realization

synchronized VS lock

Deadlock (Master)

What is deadlock

Deadlock scenario

How to resolve deadlock

Mode 1

Mode II

Producer consumer model (understand)

Inter thread communication (key)

wait

notify

notifyAll

common problem

What is the difference between sleep and wait methods?

Complete thread state transition diagram (Master)

Thread tool (Master)

Thread pool

Three thread pools

Implementation mode 3 of multithreading: implement the Callable interface

timer

Timer timer

Timed tasktimertask

Topics: Java Back-end JavaSE