并发原因
存在临界资源（临界值）
存在多条线程共同操作共享数据
话不多说直接看例子（这是小菜上一篇博文中的例子 ）
模仿抢票：
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<String> 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
版权声明：本文为博主原创文章，转载请附上博文链接！
