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

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

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

同步——这是线程 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();
	}
}

运行结果为：

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

在主函数中：

//任务对象
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();

	}
}