Tabla de contenido
usar un solo hilo
El valor del contador se modifica por un solo hilo, y no hay problema.El resultado de cada operación es 10000, pero el programa tarda mucho
package com.example;
/**
* 计数器
*/
class Counter {
private static long count;
public static long getCount() {
return count;
}
public static void incrementCount() {
count++;
}
}
public class Demo {
public static void main(String[] args) throws InterruptedException {
long count = Counter.getCount();
System.out.println(count);
// 0
for (int i = 0; i < 10000; i++) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Counter.incrementCount();
}
count = Counter.getCount();
System.out.println(count);
// 10000
}
}
usar subprocesos múltiples
El valor del contador se modifica por un solo hilo y se mejora la velocidad de ejecución, pero el resultado de la ejecución es inconsistente cada vez y el resultado no es 10000
package com.example;
import java.util.ArrayList;
import java.util.List;
/**
* 计数器
*/
class Counter {
private static long count;
public static long getCount() {
return count;
}
public static void incrementCount() {
count++;
}
}
public class Demo {
public static void main(String[] args) throws InterruptedException {
long count = Counter.getCount();
System.out.println(count);
// 0
List<Thread> list = new ArrayList<>();
// 启动10000个线程同时访问计数器
for (int i = 0; i < 10000; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Counter.incrementCount();
}
});
list.add(thread);
}
for (Thread thread : list) {
thread.start();
}
for (Thread thread : list) {
thread.join();
}
count = Counter.getCount();
System.out.println(count);
}
}
Resultados de la
第一次：9910
第二次：9912
第三次：9910
Usar subprocesamiento múltiple + sincronizado
Después del bloqueo de subprocesos múltiples, el resultado final es 10000
package com.example;
import java.util.ArrayList;
import java.util.List;
/**
* 计数器
*/
class Counter {
private static long count;
public static long getCount() {
return count;
}
public static synchronized void incrementCount() {
count++;
}
}
public class Demo {
public static void main(String[] args) throws InterruptedException {
long count = Counter.getCount();
System.out.println(count);
// 0
List<Thread> list = new ArrayList<>();
// 启动10000个线程同时访问计数器
for (int i = 0; i < 10000; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Counter.incrementCount();
}
});
list.add(thread);
}
for (Thread thread : list) {
thread.start();
}
for (Thread thread : list) {
thread.join();
}
count = Counter.getCount();
System.out.println(count);
}
}
Resultados de la
第一次：10000
第二次：10000
第三次：10000
Usar subprocesos múltiples + clase atómica AtomicLong
La clase atómica AtomicLong se usa para implementar el contador en subprocesos múltiples, y el resultado final es 10000
El principio es CAS(Comparar y Establecer):
- Primero compare el valor original y el valor esperado, y si son iguales, modifíquelo al nuevo valor;
- Si no es igual, la modificación falla
El pseudocódigo es el siguiente
bool compareAndSet(oldValue, expectValue, updateValue){
if(oldValue == expectValue){
oldValue = updateValue
// update success
} else{
// update fail
}
}
package com.example;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
/**
* 计数器
*/
class Counter {
private static AtomicLong count = new AtomicLong(0);
public static long getCount() {
return count.get();
}
public static void incrementCount() {
count.incrementAndGet();
}
}
public class Demo {
public static void main(String[] args) throws InterruptedException {
long count = Counter.getCount();
System.out.println(count);
// 0
List<Thread> list = new ArrayList<>();
// 启动10000个线程同时访问计数器
for (int i = 0; i < 10000; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Counter.incrementCount();
}
});
list.add(thread);
}
for (Thread thread : list) {
thread.start();
}
for (Thread thread : list) {
thread.join();
}
count = Counter.getCount();
System.out.println(count);
}
}
Resultados de la
第一次：10000
第二次：10000
第三次：10000
referencia