Hilo de sincronización y punto muerto
En el desarrollo de programas, todos los programas se ejecutan mediante el método principal, y el método principal en sí pertenece a un hilo principal, por lo que el nuevo objeto de hilo creado por el método principal es un hilo secundario.
El uso de subprocesos puede realizar el procesamiento de operaciones asíncronas, de modo que se pueden realizar otras operaciones sin afectar la operación del subproceso principal. La velocidad de ejecución del programa no solo se vuelve más rápida, sino que la operación no causa demasiado retraso.
Operación sincrónica
La llamada operación sincrónica significa que varias operaciones en un código solo pueden ser realizadas por un hilo en el mismo período de tiempo, y otros hilos pueden esperar a que este hilo se complete antes de continuar la ejecución.
En Java, puede usar la palabra clave sincronizada para lograr la sincronización de subprocesos. Esta palabra clave se puede usar de las siguientes dos maneras:
1. Bloque de código sincronizado: un bloque de código envuelto con sincronizado, pero debe especificar el objeto de sincronización, generalmente establecido en esto;
2 Método de sincronización: utilice el método definido por sincronizado.
Ejemplo: observar el bloque de código sincronizado
package Project.Study.Multithreading;
class MyThread7 implements Runnable{
private int ticket=10; //一共有10张票
@Override
public void run(){
for (int x=0;x<10;x++){
synchronized(this){ //定义同步代码块
if(this.ticket>0){ //判断当前是否还有剩余票
try {
Thread.sleep(100); //休眠1s，模拟延迟
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+",卖票，ticket="+this.ticket--);
}
}
}
}
}
public class Test7 {
public static void main(String [] args){
MyThread7 mt=new MyThread7();
new Thread(mt,"票贩子A").start(); //启动多线程
new Thread(mt,"票贩子B").start();
new Thread(mt,"票贩子C").start();
new Thread(mt,"票贩子D").start();
}
}
//结果：
//票贩子A,卖票，ticket=10
//票贩子A,卖票，ticket=9
//票贩子A,卖票，ticket=8
//票贩子A,卖票，ticket=7
//票贩子A,卖票，ticket=6
//票贩子A,卖票，ticket=5
//票贩子A,卖票，ticket=4
//票贩子A,卖票，ticket=3
//票贩子A,卖票，ticket=2
//票贩子A,卖票，ticket=1
Ejemplo: resuelva el problema utilizando el método de sincronización
package Project.Study.Multithreading;
class MyThread8 implements Runnable{
private int ticket=10; //一共有10张票
@Override
public void run(){
for (int x=0;x<20;x++){
this.sale(); //卖票操作
}
}
public synchronized void sale(){//同步方法
if (this.ticket>0){ //判断当前是否还有剩余票
try{
Thread.sleep(100);//休眠1s，模拟延迟
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+",卖票,ticket="+this.ticket--);
}
}
}
public class Test8 {
public static void main(String []args){
MyThread8 mt=new MyThread8();
new Thread(mt,"票贩子A").start();//启动多线程
new Thread(mt,"票贩子B").start();
new Thread(mt,"票贩子C").start();
new Thread(mt,"票贩子D").start();
}
}
//结果：
//票贩子A,卖票,ticket=10
//票贩子A,卖票,ticket=9
//票贩子A,卖票,ticket=8
//票贩子A,卖票,ticket=7
//票贩子A,卖票,ticket=6
//票贩子A,卖票,ticket=5
//票贩子A,卖票,ticket=4
//票贩子A,卖票,ticket=3
//票贩子A,卖票,ticket=2
//票贩子A,卖票,ticket=1
Nota:
1. Los métodos, estático, nativo y sincronizado no pueden declararse con "resumen" al mismo tiempo.
2. Cuando un hilo ingresa a un método sincronizado de un objeto, otros hilos no pueden acceder a otros métodos de este objeto.
3. El rendimiento del código sincronizado será menor, pero la seguridad de los datos será alta (la seguridad de los subprocesos es alta); el código asincrónico suele ser más eficiente, pero la seguridad de los subprocesos es menor (la mayoría de los datos son datos compartidos, es decir Usado por otros hilos).
Punto muerto
Demasiadas operaciones simultáneas pueden causar un problema de punto muerto, haciendo que el programa entre en un estado detenido. El llamado interbloqueo significa que dos subprocesos esperan el uno al otro para completarse primero, lo que resulta en el estancamiento del programa . En general, el interbloqueo del programa ocurre cuando el programa se está ejecutando.
Ejemplo: operación de bloqueo de programa
package Project.Study.Multithreading;
class A{
public synchronized void say(B b){
System.out.println("A先生说：把你的笔记本给我，我给你笔，否则不给！");
b.get();
}
public synchronized void get(){
System.out.println("A先生：得到了笔记本，付出了笔，还是什么都干不了!");
}
}
class B{
public synchronized void say(A a){
System.out.println("B先生说：把你的笔给我，我给你笔记本，否则不给！");
a.get();
}
public synchronized void get(){
System.out.println("B先生：得到了笔，付出了笔记本，还是什么都干不了");
}
}
public class Test9 implements Runnable{
private static A a=new A(); //定义类对象
private static B b=new B();
public static void main(String[]args){
new Test9(); //实例化本类对象
}
public Test9(){ //构造方法
new Thread(this).start(); //启动线程
b.say(a); //互相引用
}
@Override
public void run(){
a.say(b); //互相引用
}
}
//结果：
//B先生说：把你的笔给我，我给你笔记本，否则不给！
//A先生说：把你的笔记本给我，我给你笔，否则不给！
//(程序将不会再向下执行，并且不会退出，此为死锁情况出现)
En el programa anterior, debido a que ambas clases usan definiciones de métodos sincrónicos, hará que el objeto a espere a que el objeto b complete su ejecución, y que el objeto b espere a que un objeto complete su ejecución, lo que provocará un punto muerto.
