对于自定义UnSafeThread类
Public static int count;
静态同步方法:锁定当前类对象
A:Public synchronized static void increment(){
//轮流执行
//锁的是UnsafeThread类对象
//进入方法会锁SynchronizedDemo.class指向对象中的锁;出方法会释放
//SynchronizedDemo.class指向的对象中的锁
count++;
}
B: Public static void increment( ) {
synchronized(UnSafeThread.class){
//锁的是UnSafeThread类对象
count++;
}
}
同步实例方法:锁定当前对象this
C: Public synchronized void increment2(){
count++;
}
D: Public void increment3(){
synchronized(this){
count++;
}
}
同步代码块:锁定o对象
E:Object o = new Object();
synchronized(o){//对o对象锁定
count++;
}
锁定的对象的所有同步的地方,都会同步互斥
只有锁定的对象是同一个时才会同步互斥
A A 互斥
A B 互斥
A C 不互斥
A D 不互斥
A E 不互斥
Synchronized 解决线程不安全(原子性,可见性,代码重排序)
```java
public class UnSafeThread {
public static int count;
public static void main(String[] args) throws InterruptedException {
Object o = new Object();
for (int i = 0; i < 20; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j < 10000; j++) {
//count++;
increment(); //静态类对象锁定
// synchronized (o){ //对o对象锁定
// count++;
// }
decrement();
}
}
}).start();
}
while (Thread.activeCount()>2) {
Thread.yield();
}
System.out.println(count);
// 结果不是20 0000
// List<Integer> list = new ArrayList<>();
// for (int i = 0; i < 20; i++) {
// final int k = i;
// new Thread(new Runnable() {
// //内部匿名类不能使用栈里的元素i
// @Override
// public void run() {
// for (int j = 0; j < 10000; j++) {
// list.add(k * 10000 + j);
// }
// }
// }).start();
// }
// while (Thread.activeCount()>2) {
// Thread.yield();
// }
// 会抛出数组越界异常ArrayIndexOutOfBoundsException
// System.out.println(list.size());
}
public synchronized static void increment() {
//轮流执行
//锁的是UnsafeThread类对象
//进入方法会锁 SynchronizedDemo.class 指向对象中的锁;出方法会释放SynchronizedDemo.class 指向的对象中的锁
count++;
}
// public static void increment() {
// synchronized (UnSafeThread.class) {
// //锁的是UnSafeThread类的对象
// count++;
// }
// }
public synchronized static void decrement() {
count--;
}
public synchronized void increment2() {
count++;
}
public void increment3() {
synchronized (this) {
count++;
}
}
}