Dos formas de crear hilos y tres formas de sincronizar

Proceso de Introducción : Simplemente comprenda que un proceso es una aplicación.
Subproceso: es la unidad de ejecución más pequeña del proceso y es una función independiente

Función de subprocesos múltiples:
1. Para aprovechar las ventajas de múltiples núcleos de la computadora
2. Mejorar la eficiencia de la operación del programa

Método de creación
1. Heredar la clase de hilo
Pasos:
1. Escribir una clase de hilo XxxThread extiende la clase de hilo
2. Reescribir el método run ()
3. Escribir una clase de prueba y crear un objeto de hilo en la clase de prueba—> llamar al inicio () del objeto para comenzar Hilo

2. Implementar la interfaz Runnable
Pasos:
1. Escribir una clase de negocio XxxRunnableImpl implementa la interfaz Runnable
2. Anular el método run ()
3. Escribir una clase de prueba, primero crear un objeto de clase de negocio en la clase de prueba -> luego crear un hilo a través del método de construcción Objeto (objeto de clase empresarial) -> llamar al inicio () del objeto del hilo para iniciar el hilo

Nota:
1. Solo la subclase que hereda la clase Thread puede denominarse clase thread, y la subclase que implementa la interfaz Runnable se denomina clase empresarial.
2. Iniciar la clase thread es un proceso de dos pasos: crear un objeto—> object.start (), e
iniciar una clase empresarial son tres Paso: Crear objeto de clase de negocio—> crear objeto de hilo (objeto de clase de negocio) -> objeto de hilo.start ()
3. start () ejecutará el método run () en el hilo, pero solo start () es el hilo de inicio. run () solo está ejecutando el método

================================================ ==================

Método de sincronización
1. Bloqueo pesimista (planificar para el peor de los casos)
1. Bloque de código de sincronización

synchronized(同步对象){
    
    
		//有线程安全问题的代码;
}
//注意事项：作为同步对象需要满足的条件：只有一份(静态区中的静态成员或元空间中的字节码文件)

2. Método síncrono
Use la palabra clave sincronizada para modificar el método, escríbalo delante del valor de retorno, el cuerpo del método es el código con problemas de seguridad de subprocesos

Nota: Debido a que solo se necesita un objeto de clase empresarial para crearlo, y luego comience por crear un objeto de clase de subproceso.
1. Si la clase heredada usa bloques de código síncrono y controla el uso compartido a través del objeto de sincronización, debe haber solo una copia; si es una clase empresarial, esta es Pero
2. Si la clase heredada usa métodos síncronos, el método debe modificarse estáticamente; si es una clase empresarial, no es necesario

2.
Mecanismo de bloqueo de bloqueo optimista :
método de construcción ReentrantLock de la clase de realización de la interfaz de bloqueo :

1. ReentrantLock () crea una instancia de ReentrantLock, la probabilidad de adquirir el bloqueo es diferente
2. ReentrantLock (booleano justo) crea una instancia de ReentrantLock de acuerdo con la política de equidad dada. Teóricamente, la probabilidad de adquirir la cerradura es la misma

class X {
    
    
	//1.创建一个 ReentrantLock的实例。不要公平机制，效率高
	private final ReentrantLock lock = new ReentrantLock();

	/**
	* 在run()中进行调用
	*/
	public void m() {
    
    
	    lock.lock();  // 上锁
	     try {
    
    
	       	//有线程安全问题的代码
	     } finally {
    
    
	       lock.unlock();//释放锁，不然后面其他线程无法执行代码
	     }
	}
}

Nota:
1. El bloqueo pesimista y el bloqueo optimista son un término general que no solo incluye estos tres métodos.
2. Principio de bloqueo: el principio de alcance mínimo (el bloque de código bloqueado se minimiza), para garantizar la eficiencia de la ejecución, el mecanismo de bloqueo es eficiente y funcional Más potente, se recomienda utilizar
3. El método de sincronización es el más simple, si puede cumplir con los requisitos de rendimiento, se recomienda utilizar el método de sincronización

=============================================== ============
Caso clásico : Venta de entradas en múltiples ventanas (clase heredada + bloque de código)
Descripción del caso: Número total de entradas: 50, se venden tres ventanas al mismo tiempo

Clase de herencia:

public class SaleTicketTread extends Thread {
    
    
	private static int ticket=50;

	public SaleTicketTread() {
    
    
		super();
	}
	
	/**
	 * 给线程起名，为了打印看输出方便
	 * @param name
	 */
	public SaleTicketTread(String name) {
    
    
		super(name);
	}

	@Override
	public void run() {
    
    
		while (ticket>0) {
    
    
			sale();
		}
	}

	private void sale() {
    
    
		synchronized (SaleTicketTread.class) {
    
    //只有一份的对象
			if (ticket>0) {
    
    //虽然锁住了，但是还是会出现多个线程同时进入run，ticket未--，所以在下一个线程执行售票之前，先判断ticket是否卖光
				System.out.println(Thread.currentThread().getName()+",票号:"+ticket);
				ticket--;
			}
		}
	}
}

Clase de prueba

public class TicketTest {
    
    

	public static void main(String[] args) {
    
    
		SaleTicketTread ticket1= new SaleTicketTread("窗口1");
		SaleTicketTread ticket2= new SaleTicketTread("窗口2=====");
		SaleTicketTread ticket3= new SaleTicketTread("窗口3=========");
		
		ticket1.start();
		ticket2.start();
		ticket3.start();
	}
}

Análisis de código de problema: ¿Por qué necesitamos si (ticket> 0)