Java - what is thread


Event address: CSDN 21 Day Learning Challenge

1. What is a thread

To understand what a thread is, you must first understand a process

Process: A simple understanding is the running program

Thread: A thread is the smallest unit in a process, and there is at least one thread in a process

There is no concept of a process in the CPU, it only has the concept of a thread, and the CPU will quickly switch threads to execute code

Thread conference CPU is a resource, and everyone will preempt the CPU. Whoever preempts it will run whose thread

Note: The CPU can only perform one thread in the same time slice

Time slice: refers to a very microscopic time

2. The use of threads

Thread is a thread class provided to us by java. As long as it inherits Thread, our custom class is a thread class

need :

Defines a game class: his core method is to print "playing the game";

One more music category: his core method is to print "White Dragon Horse..."

There is a core method run() in the thread class; we need to override it

Then after we instantiate the thread object, we need to activate the thread object through the start() method in the Thread class so that it has the right to preempt the thread

code show as below

public class Thread_Text_1 {

    static class GameThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i <100; i++) {
                System.out.println("---->game in progress"+i);
            }
        }
    }
    static class MusicThread extends Thread{
        @Override
        public void run() {

            for (int i = 0; i <100; i++) {
                System.out.println("---->music playing"+i);
            }

        }
    }
    public static void main(String[] args) {
        GameThread gameThread=new GameThread();// Create a thread object
        gameThread.start();// Activate the thread and let the object get the execution right of the CPU

        MusicThread musicThread=new MusicThread();
        musicThread.start();
        
         for (int i = 0; i <100; i++) {
            System.out.println("---->main");
        }
    }
}

There are a total of three threads in the code

1. Main method Main Thread

2,Game Thread

3,Music Thread

3. Notes on thread usage

In future code writing, the logic code can be written directly in the Run method in the Thread class

But you can't call the Run() method directly, and calling the Run() method directly will not open a thread

The start() method needs to be called to activate the thread, so that the current thread is in an active state

When the total thread is activated and started, it has nothing to do with the main thread, and the two threads will not have any connection

4. Thread use case – train ticket sales

need

The current train station has a total of 200 train tickets

Then, three ticket windows were opened to sell train tickets at the same time.

code show as below

public class Thread_Text_2 {
    static class PiaoThread extends Thread{
        static int sum=100;
         String ThreadName;
        public PiaoThread(String threadName){
            ThreadName=threadName;
        }
        @Override
        public void run() {

           while (sum>0){
               System.out.println(ThreadName+"Tickets are being issued, ticket number is"+sum);
               sum--;
           }
        }
    }

    public static void main(String[] args) {
        // instantiate the thread object
        PiaoThread piaoThread1=new PiaoThread("window one");
        PiaoThread piaoThread2=new PiaoThread("window two");
        PiaoThread piaoThread3=new PiaoThread("window three");
        // activate thread
        piaoThread1.start();
        piaoThread2.start();
        piaoThread3.start();
    }
}

The code works theoretically. But there will be a problem of heavy tickets, which involves thread safety

Tickets are being issued at window 1, and the ticket number is 100
Tickets are being issued at window 3, and the ticket number is 100
Tickets are being issued at window 2, and the ticket number is 100

5. Thread safety issues

When thread A preempts the execution right of the CPU and the conditions are met, the ticket number is 100.

At this time, the CPU is preempted by thread B before the sum- operation is performed, so the ticket number that is still issued is still 100.

The information error phenomenon that occurs when multiple threads preempt the CPU, which is a thread safety problem

Thread safety problem Solution: lock

6. Modify the thread name

currentThread(): This method is used to return a reference to the currently executing thread object

getName(): This method is used to return the name of the current thread

There are two ways to modify the thread name

1. Name the thread through the constructor

static class PiaoThread extends Thread{
       static int sum=100;
       public PiaoThread(String threadName){
           super(threadName);
       }
}

2. Modify the thread name through the setName() method

static class PiaoThread extends Thread{
       static int sum=100;
       public PiaoThread(String threadName){
           setName(threadName);
       }
}

7. Thread sleep

The sleep() method is provided in Thread to make the thread sleep for a specified time

try {
     sleep(1000);
} catch (InterruptedException e) {
     e.printStackTrace();
}

8. Two ways to implement threads

The first is to inherit Thread through a class

Just extend Thread directly

The second is to implement Runnable through a custom class

new Thread (the implementation class of Rannable) can

Because Thread has only run() method

If you want the thread to be active and have CPU control, it must be implemented through Rannaable

code show as below

public class Thread_Text_3{
    public static void main(String[] args) {
        Thread_Runnable thread_runnable1=new Thread_Runnable();
        Thread thread1=new Thread(thread_runnable1);
        thread1.start();

        Thread_Runnable thread_runnable2=new Thread_Runnable();
        Thread thread2=new Thread(thread_runnable2);
        thread2.start();

        Thread_Runnable thread_runnable3=new Thread_Runnable();
        Thread thread3=new Thread(thread_runnable3);
        thread3.start();
    }
    static class Thread_Runnable implements Runnable{
        static int sum=100;
        @Override
        public void run() {
            while (sum>0){
                System.out.println(Thread.currentThread().getName()+"sell"+sum);
                sum--;
            }
        }
    }
}

9. Solve thread safety issues

There are three ways to solve the problem of thread safety

1, synchronized synchronization code block

2. Synchronization method

3. Use Lock

The essence of these three methods is to lock the code

Notice :

To lock the code, you must ensure that the code that needs to be locked uses the same lock

How does a synchronized code block ensure that the locked code is the same lock?

Just use bytecode objects a unique bytecode object exists for each class

class name.class: you can

1. Code synchronization block

@Override
public void run() {
	while (sum>0){
		synchronized (Thread_Runnable.class){
			if (sum>0){
				System.out.println(Thread.currentThread().getName()+"sell"+sum+"");
                sum--;
            }
		}
	}
}

2. Synchronization method

Synchronous methods only need to encapsulate the code to be executed into a method

Just add the synchronized declaration before the method void declaration

Note that if you implement Thread using inheritance then you cannot use synchronized methods

3. Lock

This method is more extensive and flexible than synchronized

We create a lock object by instantiating the Lock object

code show as below

public class Thread_Text_4 {

    static class Thread_ extends Thread{
        int sum=100;
        static Lock lock =new ReentrantLock(); // Create lock object

        @Override
        public void run() {
            // locked
            while (sum>0){
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName()
                            + "Tickets are being issued, ticket number is"
                            + sum
                            + " "
                            + Thread.currentThread().getName() +
                            " "
                    );
                    sum--;
                }finally {
                    lock.unlock();
                }

            }
        }
    }

    public static void main(String[] args) {
        Thread_ thread1=new Thread_();
        Thread_ thread2=new Thread_();
        Thread_ thread3=new Thread_();
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

Notice:

The Lock instance object must ensure that the participating threads are all using the same lock, so you need to add Static

Then lock through the Lock.lock() method

Release the lock through the Lock.unlock() method

Use these two methods must cooperate with Try...finally to ensure that resources can be released even if the code reports an error

Tags: Java jvm programming language

Posted by rajmohan on Mon, 12 Sep 2022 21:15:45 +0300