Introduction to the use of some basic methods of multithreading in Java (with examples)

This article brings you an introduction to the use of some basic methods in multi-threading in Java (with examples). It has a certain reference value. Friends in need can refer to it. I hope it will be useful to you. help.

Thread sleep sleep()

Thread.sleep(milliseconds); We can set the thread to sleep through the sleep method. You can see that sleep is a static method

public static native void sleep(long var0) throws InterruptedException;

    try {
        System.out.println(new Date().getSeconds());
        Thread.sleep(5000);
        System.out.println(new Date().getSeconds());
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

setDaemon daemon thread

The non-daemon thread stops, then the daemon thread automatically exits

    public static void main(String[] args) {
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                super.run();
                for(int i = 0; i < 5; i ++) {
                    System.out.println("非守护线程");
                }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    System.out.println("守护线程");
                }
            }
        };

        thread2.setDaemon(true);
        thread1.start();
        thread2.start();
    }

It is obvious that thread2 should be executed 200 times of output, but only a few lines are output here. Because when thread1 completes execution, thread2 automatically stops as a daemon thread.

Multi-thread jion

If the jion method is executed, stop the current thread and run the thread that executed jion() first. It is equivalent to queue-jumping execution. As follows, when executing the thread2 thread, if i==20, let thread1 jump in the queue and execute it first

    public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println("thread1---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    if (i == 20) {
                        try {
                            //插队执行
                            thread1.join();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(i);
                }
            }
        };
        thread1.start();
        thread2.start();
    }

join() method can also pass the parameter long milliseconds join (milliseconds)
means to let the execution The join thread jumps in the queue and executes for ##setPriority sets the priority for the thread

The default priority is 5, minimum 1, maximum 10

The larger the priority, the higher the priority

   public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println("thread1---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    if (i == 20) {
                        try {
                            //插队执行１毫秒
                            thread1.join(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(i);
                }
            }
        };
        thread1.start();
        thread2.start();
    }

synchronized

Synchronized code block

When multiple threads are concurrent and multiple pieces of code are executed at the same time. I hope that when executing the code, the CPU will not switch threads

Situation without synchronized

Let’s take a look at what will happen without synchronized

    public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println( getName() + "---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    if (i % 5 == 0) {
                        Thread.yield();
                    }
                    System.out.println(getName() + "---" + i);
                }
            }
        };
        thread1.start();
        thread2.start();
    }

We found that some output was not fully printed. During the execution of thread thread1, the cpu was preempted by thread2. In this case, it is definitely not in line with our business logic. So we have to ensure that the CPU will be preempted by other threads only after the thread executes a complete method

Use synchronized

    public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println( getName() + "---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 500; i ++) {

                    System.out.println(getName() + "---" + i);
                }
            }
        };
        //设置最大的线程优先级最大为10
        thread1.setPriority(Thread.MIN_PRIORITY);
        //设置最小的线程优先级，最小为１
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }

After using synchronized synchronization code block , you will find that the above situation will not occur

Synchronization method

public class ThreadSynchronied {

    public static void main(String[] args) {
        final Say say = new Say();

         Thread thread1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say();
                }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say1();
                }
            }
        };
        //设置最大的线程优先级最大为10
        thread1.setPriority(Thread.MIN_PRIORITY);
        //设置最小的线程优先级，最小为１
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }
}

class Say {
    void say() {
        System.out.print("s ");
        System.out.print("a ");
        System.out.print("y ");
        System.out.print("h ");
        System.out.print("e ");
        System.out.print("l ");
        System.out.print("l ");
        System.out.println("o");
    }

    void say1() {
        System.out.print("1 ");
        System.out.print("2 ");
        System.out.print("3 ");
        System.out.print("4 ");
        System.out.print("5 ");
        System.out.print("6 ");
        System.out.print("7 ");
        System.out.println("8");
    }
}

The synchronization method refers to locking the method

The object of the static synchronization method is of this class Bytecode object

The non-static synchronization method lock object is this

Multiple threads use the same resource lock, which can easily cause deadlock

What is a deadlock?

Deadlock refers to a blocking phenomenon caused by two or more processes competing for resources or communicating with each other during execution. Without external force, they will not be able to advance. At this time, the system is said to be in a deadlock state or the system has a deadlock. These processes that are always waiting for each other are called deadlock processes.

Thread-safe class

Vector

StringBuffer
HashTable

Thread-unsafe

ArrayList
StringBuilder
HashSet

java.util.Collections has synchronizedList and other methods, which support us to convert thread-unsafe collections into thread-safe ones

The above is the detailed content of Introduction to the use of some basic methods of multithreading in Java (with examples). For more information, please follow other related articles on the PHP Chinese website!