多线程基础2：同步方法与同步块

并发原因

存在临界资源（临界值）
存在多条线程共同操作共享数据
话不多说直接看例子（这是小菜上一篇博文中的例子 ）
模仿抢票：

package thread;

public class Ticket_garbbing implements Runnable{
    private int tickrtSize=100;
    @Override
    public void run() {
        while(true) {
            if (tickrtSize < 0) {
                break;
            }
            try {
                Thread.sleep(200);//模仿网络延时此时出现负数出现并发问题
            } catch (InterruptedException e) {//并发需要保证线程安全
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"/"+tickrtSize--);
        }
    }

    public static void main(String[] args) {
        Ticket_garbbing tg1=new Ticket_garbbing();
        new Thread(tg1,"io1").start();
        new Thread(tg1,"io2").start();
        new Thread(tg1,"io3").start();
        new Thread(tg1,"io4").start();
        new Thread(tg1,"io5").start();
        new Thread(tg1,"io6").start();
    }
}

运行结果：

image.png

为什么这里会出现负数呢？按道理程序运行到0就应该结束了。其实这是因为此处发生了并发。我们都知道每一个线程都有一个独立的线程空间。当前有六个线程，要从主内存中拿到票，假如他们都拿到票此时票数为1，此时io5将票抢到，此时票为0，那剩下拿到票的线程只好继续操作。如下图：

image.png

解决方法

同步方法（加锁锁定当前对象也就是this）
同步块（加锁锁定某对象通常在块上加锁）
代码如下：

package thread2;
/*
* 线程不安全
* 相同或者负数都不安全
* synchrohized同步方法
* 同步块
* */
public class webtickets implements Runnable{
    private int tickrtSize=100;
    private boolean flag=true;
    //线程安全同步
    public synchronized void stop(){
        if(tickrtSize<=0){
            flag=false;
            return;
        }
        try {
            Thread.sleep(200);//模仿网络延时此时出现负数出现并发问题
        } catch (InterruptedException e) {//并发需要保证线程安全
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"/"+tickrtSize--);
    }
    @Override
    public void run() {
        while (flag){
            stop();
        }

    }

    public static void main(String[] args) {
        webtickets tg1=new webtickets();
        new Thread(tg1,"io1").start();
        new Thread(tg1,"io2").start();
        new Thread(tg1,"io3").start();
       /* new Thread(tg1,"io4").start();
        new Thread(tg1,"io5").start();
        new Thread(tg1,"io6").start();*/
    }
}

运行结果：

image.png

加锁原理：
举个简单的例子吧，比如多个人此时在排队上厕所，如果厕所可以随便可以出入，那可能就会造成两个同时争抢厕所的情况。那如果厕所可以上锁，一人为用完其他人也不能使用，必须等厕所解锁以后才能允许下一个人使用。其实加锁就是在其资源上加上一个限制，一次只能一个线程使用资源。

我们再来看看同步块的例子：

未加锁：

package thread2;

public class GetMoney {
    public static void main(String[] args) {
        Accout accout=new Accout(100,"tom");
        Drawing d1=new Drawing(accout,10,accout.money);
        Drawing d2=new Drawing(accout,20,accout.money);
        new Thread(d1).start();
        new Thread(d2).start();
    }
}

class Accout{
    int money;
    String name;
    public Accout(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing implements Runnable{
    Accout accout;
    int drawingMoney;
    int drawtotal;

    public Drawing(Accout accout, int drawingMoney, int drawtotal) {
        this.accout = accout;
        this.drawingMoney = drawingMoney;
        this.drawtotal = drawtotal;
    }

    @Override
    public void run() {
        test();
    }
    public  void test(){
      
           accout.money -= drawingMoney;
           System.out.println(accout.money + "--" + accout.name + "-" + drawtotal);
      
    }
}

加锁：

package thread2;

public class GetMoney {
    public static void main(String[] args) {
        Accout accout=new Accout(100,"tom");
        Drawing d1=new Drawing(accout,10,accout.money);
        Drawing d2=new Drawing(accout,20,accout.money);
        new Thread(d1).start();
        new Thread(d2).start();
    }
}

class Accout{
    int money;
    String name;
    public Accout(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing implements Runnable{
    Accout accout;
    int drawingMoney;
    int drawtotal;

    public Drawing(Accout accout, int drawingMoney, int drawtotal) {
        this.accout = accout;
        this.drawingMoney = drawingMoney;
        this.drawtotal = drawtotal;
    }

    @Override
    public void run() {
        test();
    }
    public  void test(){
    //此时针对某个对象如果将锁加在test并发非同步
       synchronized (accout) {//更加的明确
           accout.money -= drawingMoney;
           System.out.println(accout.money + "--" + accout.name + "-" + drawtotal);
       }
    }
}

第三个例子

package thread2;

import java.util.ArrayList;
import java.util.List;

public class Test3 {
    public static void main(String[] args) {
        List list=new ArrayList<>();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                synchronized (list) {
                    list.add("1");
                }
            }).start();
        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

未加锁结果：
8592
加锁结果：
10000

小结
并发同步是要牺牲性能的。

---

作者：欲指_Object
来源：CSDN
原文：https://blog.csdn.net/apple596529/article/details/89481592
版权声明：本文为博主原创文章，转载请附上博文链接！