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

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

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

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

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

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

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

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

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

//需要被同步的代码；

}

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

[java] view plain copy print?

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. 必须要保证多个线程在同步中使用的是同一个锁。这是才称为多个线程被同步了！

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

[java] view plain copy print?

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--);
}
}
}
}
}

[java] view plain copy print?

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标记后，他也就具备了同步性。

上述代码经过修改后：

[java] view plain copy print?

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

[java] view plain copy print?

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();
}
}

秒客网

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

相关文章