How to implement multi-threading

● Inherit the Thread class to create a thread class and override the run method. The run method represents the task that the thread needs to complete. Call Start() of the thread object to start the thread. The thread class has inherited the Thread class, so it cannot inherit other parent classes.

class ThreadTest extends Thread {  

    Thread thread;  

    public ThreadTest(Thread thread) {  
      this.thread = thread;  
  }  

   @Override  
   public void run() {  
      synchronized (thread) {  
          System.out.println("getObjectLock");  
         try {  
             Thread.sleep(9000);  
       } catch (InterruptedException ex) {  
          ex.printStackTrace();  
         }  
           System.out.println("ReleaseObjectLock");  
    }  
   }  
 }

Copy after login

● Implement the Runnable interface to create a thread class, define the Runnable implementation class, and override the run method

  class RunnableImpl implements Runnable {  
    
     public void run() {  
          try {  
             System.out.println("Begin sleep");  
             Thread.sleep(2000);  
             System.out.println("End sleep");  
          } catch (InterruptedException e) {  
              e.printStackTrace();  
          }  
      }  
   }

Copy after login

● Implement the Callable interface, override the call() method, and call() as the execution of the thread Body, with return value

● Thread pool, use the thread pool to generate thread objects java.util.concurrent.ExecutorService, java.util.concurrent.Executors;

How does Java implement thread safety

● Mutually exclusive synchronization: It is recommended to use the synchronized keyword for synchronization. There is the ReentrantLock class in the concurrent package, and the implementation effect is similar. The original synchronized is still recommended.
● Non-blocking synchronization: requires hardware instructions to complete. Commonly used instructions are: Test-and-Set Fetch-and-Increment Swap Compare-and-Swap (CAS) Load-Linked/Store-Conditional (LL/SC) Typical applications: AtomicInteger in
● No synchronization solution: Save the variables in the local thread, so there will be no concurrent errors of multiple threads. The main thing used in java is the ThreadLocal class.

Join() method

thread.Join adds the specified thread to the current thread, and can merge two alternately executing threads into sequential execution threads. For example, if the Join() method of thread A is called in thread B, thread B will not continue to execute until thread A completes execution.

t.join(); //Let the calling thread t complete execution before this.
t.join(1000); //Waiting for t thread, the waiting time is 1000 milliseconds, and the timeout will not wait.

public class JoinTest implements Runnable{  

    public static int a = 0;  

    public void run() {  
        for (int k = 0; k < 5; k++) {  
            a = a + 1;  
        }  
    }  

    public static void main(String[] args) throws Exception {  
        Runnable r = new JoinTest();  
        Thread t = new Thread(r);  
        t.start();        
        t.join();//等待t线程完成后输出，可保证a=5；
        System.out.println(a);  
    }         
}

Copy after login

wait()

The wait method of Object has three layers loading method, one of which, wait(), waits indefinitely (always) until other threads call the notify or notifyAll method to wake up the current thread; the other two methods, wait(long timeout) and wait(long timeout, int nanos), allow passing Enter the time that the current thread needs to wait before being awakened. timeout is the number of milliseconds and nanos is the number of nanoseconds.

notify()

The notify method only wakes up a waiting (object's) thread and causes the thread to start executing. So if there are multiple threads waiting for an object, this method will only wake up one of the threads, and which thread to choose depends on the operating system's implementation of multi-thread management.

notifyAll()

notifyAll will wake up all waiting (object) threads, although which thread will be processed first depends on the operating system implementation.
These methods can be used in the "producer-consumer" problem. The consumer is the thread waiting for the object in the queue, and the producer is the thread that releases the object in the queue and notifies other threads.

How to implement multi-threading

● Inherit the Thread class to create a thread class and override the run method. The run method represents the task that the thread needs to complete. Call the start() of the thread object to start the thread. Thread, the thread class has inherited the Thread class, so it cannot inherit other parent classes.

class ThreadTest extends Thread {  

    Thread thread;  

    public ThreadTest(Thread thread) {  
      this.thread = thread;  
  }  

   @Override  
   public void run() {  
      synchronized (thread) {  
          System.out.println("getObjectLock");  
         try {  
             Thread.sleep(9000);  
       } catch (InterruptedException ex) {  
          ex.printStackTrace();  
         }  
           System.out.println("ReleaseObjectLock");  
    }  
   }  
 }

Copy after login

● Implement the Runnable interface to create a thread class, define the Runnable implementation class, and override the run method

  class RunnableImpl implements Runnable {  
    
      public void run() {  
          try {  
              System.out.println("Begin sleep");  
              Thread.sleep(2000);  
              System.out.println("End sleep");  
          } catch (InterruptedException e) {  
              e.printStackTrace();  
           }  
       }  
   }

Copy after login

● Implement the Callable interface, override the call() method, and call() as the execution of the thread Body, with return value

● Thread pool, use the thread pool to generate thread objects java.util.concurrent.ExecutorService, java.util.concurrent.Executors;

How does Java implement thread safety

Join() method

t.join(); //Let the calling thread t complete execution before this.
t.join(1000); //Waiting for t thread, the waiting time is 1000 milliseconds, and the timeout will not wait.

public class JoinTest implements Runnable{  

    public static int a = 0;  

    public void run() {  
        for (int k = 0; k < 5; k++) {  
            a = a + 1;  
        }  
    }  

    public static void main(String[] args) throws Exception {  
        Runnable r = new JoinTest();  
        Thread t = new Thread(r);  
        t.start();        
        t.join();//等待t线程完成后输出，可保证a=5；
        System.out.println(a);  
    }         
}

Copy after login

wait()

notify()

The notify method only wakes up a waiting (object's) thread and causes the thread to start execution. So if there are multiple threads waiting for an object, this method will only wake up one of the threads, and which thread to choose depends on the operating system's implementation of multi-thread management.

notifyAll()

The above is the detailed content of Multi-threading implementation and thread safety in Java development. For more information, please follow other related articles on the PHP Chinese website!