Java多线程技术初识——4. 多线程安全问题的解决

时间：2022-01-23 17:30:30

多线程安全问题的解决方案：

首先我们得明白两个概念：同步 和 互斥；

同步——这是线程 or  进程之间的 合作关系。对多个线程在执行次序上进行协调，以使并发的各个线程能更好的利共享资源，相互合作。多个线程之间，一个线程需要等待另一个线程执行完毕后才能继续执行。 如：下文中，当一个线程拿到锁没有释放之前另一个线程不能执行，只能是等待上个线程 释放了锁之后才能执行。

 

互斥——这是线程 or  进程之间的 竞争关系。在生产者消费者的例子中，当有生产者在写的时候，消费者就不能读，他们在竞争 缓冲区。

 

只要 保证一个线程在执行多条操作共享数据的语句时，其他线程不能参与运算即可。

当该线程都执行完后，其他线程才可以执行这些语句。

Java为我们提供了具体的解决方案——同步代码块。

synchronized（对象）{ // 对象可以是 任意的对象

//需要被同步的代码；

}


在上个例子中加入synchronized 后，代码如下：

package chapter1502;

public class Ticket1 implements Runnable{
private int tickets = 100;

private Object obj = new Object();
//线程任务
public void run(){
while(true){
synchronized(obj){ //加锁
if(tickets>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "    " + tickets--);
}
}
}
}
}
至此，就解决了 上篇所提及的 线程安全问题！

下面介绍三个问题：同步的原理，同步的好处,弊端 ，同步的前提


同步的原理：其实就是将需要同步的代码进行封装，并在该代码上加了一个锁。

同步的好处，弊端：

好处：使多线程处于能够安全的运行。

弊端：在加了多线程之后，多个线程在对锁申请使用权的时候，会使CPU不断的切换，，这样做，会引起性能的降低。


同步的前提：

1. 必须要保证在同步中有多个线程。      因为同步中只有一个线程该同步是没有意义的。

2. 必须要保证多个线程在同步中使用的是同一个锁。这是才称为 多个线程被同步了！


关于同步的前提，请看下例代码：

package chapter1502;

public class Ticket1 implements Runnable{
private int tickets = 100;

//线程任务
public void run(){
Object obj = new Object();
while(true){
synchronized(obj){ //加锁
if(tickets>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "    " + tickets--);
}
}
}
}
}
public class SaleTicket2 {public static void main(String[] args) {//任务对象Ticket1 t1 = new Ticket1();//线程对象Thread td1 = new Thread(t1);Thread td2 = new Thread(t1);Thread td3 = new Thread(t1);Thread td4 = new Thread(t1);//开启线程td1.start();td2.start();td3.start();td4.start();}}



运行结果为：

Java多线程技术初识——4. 多线程安全问题的解决

运行后发现，即使加了同步 ，加了锁，然而问题依旧，这是为什么呢？

在主函数中：

//任务对象
Ticket1 t1 = new Ticket1();
//线程对象
Thread td1 = new Thread(t1);
Thread td2 = new Thread(t1);
Thread td3 = new Thread(t1);
Thread td4 = new Thread(t1);

//开启线程
td1.start();
td2.start();
td3.start();
td4.start();


当我们在主函数中，创建了线程对象后，注意，每个run()方法中，都有一个锁，因为他们自己用的自己的锁，所以 同步就相当于没加，所以会再次出现这样的问题，故而，当我们在为同步加锁的时候，一定得保证，加的锁是同一把锁。

同步函数：函数本身没有同步性，当我们为他加上 synchronized标记后，他也就具备了同步性。

上述代码经过修改后：

class Ticket implements Runnable
{
private int num = 100;
private Object obj = new Object();
public  void run()
{
while(true)
{
show();
}
}
//同步函数
public synchronized void show()
{
if(num>0)
{
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+".....sale....."+num--);
}
}
}
class TicketDemo3 
{
public static void main(String[] args) 
{
Ticket t = new Ticket();

//创建线程对象。

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);

t1.start();
t2.start();
t3.start();
t4.start();

}
}

那么，同样是同步，同步函数和同步代码块的区别：

1. 同步函数比同步代码块 写法简单。

2. 同步函数使用的锁是 this . 同步代码块使用的是 任意指定的对象。


下面主要介绍一下，锁——同步代码块，同步函数，静态同步函数使用的锁：

1. 同步代码块使用的锁是：任意的对象；

2. 同步函数使用的锁是： this , this代表当前对象的引用。

3. 静态——当一个类被加载进内存以后，在我们还没有创建对象的时候，已经有对象了Xx.class。

静态随着类的加载而加载，这时内存中存储的对象至少有一个  就是该类字节码文件对象。

这个对象的表示方式： 类名.class 

class StaticLockDemo 
{
public static void main(String[] args) 
{
Ticket t = new Ticket();

//创建线程对象。

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);

t1.start();
try{Thread.sleep(10);}catch(InterruptedException e){}
//在开启了t1后，将标记置为false。
t.setFlag();

t2.start();


}
}

class Ticket implements Runnable
{
private static  int num = 200;
private boolean flag = true;
public  void run()
{
if(flag)//为true就执行同步代码块。
while(true)
{
synchronized(Ticket.class)
{
if(num>0)
{
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+".....code.........."+num--);
}
}
}
else//为false就执行同步函数。 
while(true)
{
show();
}
}
/*
将标记改为false。
*/
public void setFlag()
{
flag = false;
}

public static synchronized void show()
{
if(num>0)
{
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"............func....."+num--);
}
}
}

class StaticLockDemo 
{
public static void main(String[] args) 
{
Ticket t = new Ticket();

//创建线程对象。

Thread t1 = new Thread(t);
Thread t2 = new Thread(t);

t1.start();
try{Thread.sleep(10);}catch(InterruptedException e){}
//在开启了t1后，将标记置为false。
t.setFlag();

t2.start();

}
}
标签：

相关文章