高并发处理之Synchronized学习(四)

根据所学的并发控制，解决之前抛出的消失的请求问题

package com.gwh.lock.test;

/**
 * 解决：
 * 不使用并发手段带来的后果
 * 消失的请求数
 * 预期结果是200000，但是每次都会不同
 */
public class DIsappearRequest2 implements Runnable{

    public static DIsappearRequest2 instance=new DIsappearRequest2();

   public static  int i=0;

    public static void main(String[] args) {
        try {
            //创建2个线程
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();
            t2.start();
            //为保证输出是在两个线程结束后需要用到join方法 join方法是在线程1方法执行完之前都会进行阻塞，直到线程1方法执行完成后，就会执行线程2方法然后阻塞，直到线程2方法执行完成以后才会输出最终的结果
            t1.join();
            t2.join();

            System.out.println("最终的结果为："+i);
        }catch (Exception e){
            e.printStackTrace();
        }


    }

   /* @Override
    public void run() {
        synchronized (DIsappearRequest2.class) {
            for (int j = 0; j < 100000; j++) {
                i++;
            }
        }

    }*/

    /*@Override
    public void run() {
        synchronized (this) {
            for (int j = 0; j < 100000; j++) {
                i++;
            }
        }
    }*/

  /*  @Override
    public synchronized void run() {
        for (int j = 0; j < 100000; j++) {
            i++;
        }
    }*/

    @Override
    public void run() {
        method();
    }

    public static synchronized void method(){
        for (int j = 0; j < 100000; j++) {
            i++;
        }
    }

}

第一种解决方式，加方法锁


第二种方式，加synchronized代码块


第三种方式，加*.class锁


最后一种方式，静态锁