Duas maneiras de criar threads e três maneiras de sincronizar

Introdução
Processo: Simplesmente entenda que um processo é uma aplicação
Thread: é a menor unidade de execução do processo e é uma função independente

Função multi-threading:
1. A fim de aproveitar as vantagens do multi-core do computador
2. Melhorar a eficiência da operação do programa

Método de criação
1. Herdar a classe Thread
Passos:
1. Escrever uma classe thread XxxThread extends Thread class
2. Reescrever o método run ()
3. Escrever uma classe de teste e criar um objeto thread na classe de teste—> chamar start () do objeto para iniciar Fio

2. Implementar a interface Runnable
Passos:
1. Escreva uma classe de negócios XxxRunnableImpl implementa a interface Runnable
2. Substitua o método run ()
3. Escreva uma classe de teste, primeiro crie um objeto de classe de negócios na classe de teste -> em seguida, crie um encadeamento por meio do método de construção Object (objeto de classe de negócio) -> chame o start () do objeto thread para iniciar o thread

Nota:
1. Apenas a subclasse que herda a classe Thread pode ser chamada de classe thread, e a subclasse que implementa a interface Runnable é chamada de classe de negócios.
2. Iniciar a classe de thread é um processo de duas etapas: crie um objeto—> object.start () e
inicie uma classe de negócios é três Etapa: Criar objeto de classe de negócios—> criar objeto de thread (objeto de classe de negócios) -> thread object.start ()
3. start () executará o método run () no thread, mas apenas start () é o thread de início. run () está apenas executando o método

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

Método de sincronização
1. Bloqueio pessimista (plano para o pior caso)
1. Sincronizar bloco de código

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

2. Método síncrono
Use a palavra-chave synchronized para modificar o método, escreva-o antes do valor de retorno, o corpo do método é o código com problemas de segurança de thread

Nota: Porque apenas um objeto de classe de negócios é necessário para criá-lo e, em seguida, comece criando um objeto de classe de thread.
1. Se a classe herdada usa blocos de código síncronos e controles compartilhados por meio do objeto de sincronização, deve haver apenas uma cópia; se for uma classe de negócios, isso é Mas
2. Se a classe herdada usa métodos síncronos, o método deve ser modificado estaticamente; se for uma classe de negócio, não é necessário

2.
Mecanismo de bloqueio otimista :
método de construção ReentrantLock da classe de realização da interface de bloqueio :

1. ReentrantLock () cria uma instância de ReentrantLock, a probabilidade de adquirir o bloqueio é diferente
2. ReentrantLock (boolean fair) cria uma instância de ReentrantLock de acordo com a política de justiça fornecida. Teoricamente, a probabilidade de adquirir a fechadura é a mesma

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

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

Nota:
1. Bloqueio pessimista e bloqueio otimista são um termo geral, não incluindo apenas esses três métodos.
2. Princípio de bloqueio: o princípio do escopo mínimo (o bloco de código bloqueado é minimizado), a fim de garantir a eficiência de execução, o mecanismo de bloqueio é eficiente e funcional Mais poderoso, recomenda-se o uso de
3. O método de sincronização é o mais simples, se puder atender aos requisitos de desempenho, recomenda-se usar o método de sincronização

======================================================= ============
Caso clássico : Venda de ingressos em múltiplas janelas (classe herdada + bloco de código)
Descrição do caso: Número total de ingressos: 50, três janelas são vendidas ao mesmo tempo

Classe de herança:

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--;
			}
		}
	}
}

Aula de teste

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álise do código do problema: Por que precisamos if (ticket> 0)