I. progress

Concept:

Characteristic:

Time slice:

Two, thread

Concept:

Relationship between process and thread

3, Features of multithreading

Randomness

Thread state

4, Multithreading creation

Inherit Thread:

The Thread class essentially implements an instance of the Runnable interface, representing an instance of a Thread. The only way to start a Thread is through the start() instance method of the Thread class. The start () method is a native method, which will notify the underlying operating system, and finally the operating system will start a new Thread, and the operating system will execute the run () method. It's very simple to implement multithreading in this way. You can start a new Thread and execute the self-defined run() method by directly extending the Thread with your own class and copying the run() method. The simulation opens multiple threads, each calling the run () method.

To implement the Runnable interface:

If your own class already extends another class, you cannot inherit more. At this time, you can implement a Runnable interface.

Comparison:

Ticket sales:

Inheriting Thread

public class TestThread {

	public static void main(String[] args) {

		Ticket t1 = new Ticket("one");
		Ticket t2 = new Ticket("two");
		Ticket t3 = new Ticket("three");
		Ticket t4 = new Ticket("four");
		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}

class Ticket extends Thread {
	static int tickets = 100;

	Ticket(String name) {
		super(name);
	}

	public void run() {
		while (true) {

			// 1. In multithreading, data is unsafe -- the reason is: the characteristics of multithreading randomness + access delay
			// 2. Question: sell the same ticket repeatedly + sell the negative ticket

			// When tickets = 1, t1,t2,t3,t4 can work
			if (tickets > 0) {

				// t1,t2,t3,t4 sleep when tickets = 1
				try {
					sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				// When tickets = 1, t1 wakes up first, outputs 1, and tickets becomes 0
				// When tickets = 2, t1 wakes up first, outputs 0, and tickets becomes - 1
				// When tickets = 3, t1 wakes up first, outputs - 1, and tickets changes to - 2
				// When tickets = 4, t1 wakes up first, outputs - 2, and tickets changes to - 3

				// The same data situation: when the thread tickets has not been output, another thread comes to work
				System.out.println(getName() + "Ticket number:" + tickets--);
			} else {
				break;
			}
		}
	}
}

Implement Runnable

public class TestThread2 {

	public static void main(String[] args) {

		Ticket2 t = new Ticket2();

		Thread t1 = new Thread(t, "one");
		Thread t2 = new Thread(t, "two");
		Thread t3 = new Thread(t, "three");
		Thread t4 = new Thread(t, "four");
		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}

class Ticket2 implements Runnable {
	int tickets = 100;

	public void run() {
		while (true) {

			// 1. In multithreading, data is unsafe -- the reason is: the characteristics of multithreading randomness + access delay
			// 2. Question: sell the same ticket repeatedly + sell the negative ticket

			// When tickets = 1, t1,t2,t3,t4 can work in java.lang
			if (tickets > 0) {

				// t1,t2,t3,t4 sleep when tickets = 1
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				// When tickets = 1, t1 wakes up first, outputs 1, and tickets becomes 0
				// When tickets = 2, t1 wakes up first, outputs 0, and tickets becomes - 1
				// When tickets = 3, t1 wakes up first, outputs - 1, and tickets changes to - 2
				// When tickets = 4, t1 wakes up first, outputs - 2, and tickets changes to - 3

				// The same data situation: when the thread tickets has not been output, another thread comes to work
				System.out.println(Thread.currentThread().getName() + "Ticket number:" + tickets--);
			} else {
				break;
			}
		}
	}
}

5, Synchrolock

synchronized
 Synchronized (object){
    Code to be synchronized;
}

Characteristic

Case study:

public class TestThread3 {

	public static void main(String[] args) {

		Ticket3 t = new Ticket3();

		Thread t1 = new Thread(t, "one");
		Thread t2 = new Thread(t, "two");
		Thread t3 = new Thread(t, "three");
		Thread t4 = new Thread(t, "four");

		t1.start(); // The run method is called, not from scratch from the Ticket3 class, but from the run method
		t2.start();
		t3.start();
		t4.start();

	}
}

class Ticket3 implements Runnable {
	int tickets = 100;
	Object obj = new Object();

	public void run() {
		while (true) {

			// synchronized synchronization keyword can ensure data security and avoid concurrency
			// new Object() is a lock object, which is equivalent to adding a lock to new Object(). The thread accesses it with a key, and waits for the one without the key.
			// Lock position: must be the starting position of multithreading concurrency
			// The lock object of new Object() is not the same object. Each thread will create its own lock object, which is invisible between threads
			// synchronized (new Object()) {
			synchronized (obj) { // Or change obj to this. It must be the same object
				if (tickets > 0) {

					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "Ticket number:" + tickets--);
				} else {
					break;
				}
			}
		}
	}
}

6, Other ways of thread creation

ExecutorService/Executors

api

        ExecutorService

        execute(Runnable Task object) Drop task to thread pool

        Executors Tool class to assist in creating thread pool

        newFixedThreadPool(5) Thread pool of up to 5 threads

        newCachedThreadPool() Enough threads,Make the task unnecessary to wait

        newSingleThreadExecutor() Thread pool with only one thread

Case study:

//Impersonate thread pool
//ExecutorService function: improve the read-write efficiency of multi-threaded operations. All threads in the thread pool are runnable, no new, no start,
//If necessary, it will be taken away. When it is used up, it will be automatically returned to the pool to ensure the use of the next thread and improve the availability of the thread.
public class TestThread4 {

	public static void main(String[] args) {

		// Start Thread.start()
		// 1. Create a thread pool -- all threads in the pool are runnable
		// 2. Create the fixed thread pool newFixedThreadPool through the Executors tool class created by the thread pool
		ExecutorService pool = Executors.newFixedThreadPool(3);

		// 3. Use thread pool to work execute(m)
		// m is of Runnable type. Why can thread4 be used? Because thread4 is the interface grandson of Runnable
		for (int i = 0; i < 10; i++) {
			// pool.execute(new Thread4(i));
			pool.execute(new MyRunnable(i));
		}

	}
}
//Create multithreaded class mode 1
class Thread4 extends Thread {

	int i;

	Thread4() {
	}

	Thread4(int i) {
		this.i = i;
	}

	public void run() {
		System.out.println(getName() + ":" + i);
	}
}
//Create multithreaded class mode 2 -- recommended!!
class MyRunnable implements Runnable {

	int i;

	MyRunnable() {

	}

	MyRunnable(int i) {
		this.i = i;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName() + ":" + i);
	}
}

Callable/Future

Case study:

public class TestThread5 {

	// Test Callable to implement multithreading
	public static void main(String[] args) throws InterruptedException, ExecutionException {

		// Create thread pool object
		ExecutorService pool = Executors.newSingleThreadExecutor(); //Create a thread pool with only one thread

		// How to execute call? -- educetorservice. Submit()
		Future future = pool.submit(new MyCallable());

		// Get the return value of call()
		Object o = future.get();
		System.out.println(o);
	}
}

class MyCallable implements Callable {
	@Override
	public Object call() throws Exception {
		// TODO Auto-generated method stub
		return new Random().nextInt(100);
	}
}

The difference between Callable and Runnable