黑马程序员——多线程（二）

最新推荐文章于 2024-10-06 20:16:20 发布

kolen001

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量326

点赞数

文章标签： java 线程线程安全黑马程序员

本文链接：https://blog.csdn.net/kolen001/article/details/46137255

版权

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

-多线程安全问题产生的原因以及解决方法

多线程安全问题产生的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，就有其他线程参与进来执行，导致共享数据出错。

解决方法的思想：对多条操作共享数据的语句，只能让一个线程先执行，过程中其他线程不能参与进来

Java对于多线程的安全问题提供了专业的解决方式：同步代码块

synchronized(obj)

{

需要同步的代码

}

对象如同锁的钥匙，持有钥匙的线程可以在同步代码中执行，没有持有锁钥匙的，即使获取了cpu的执行权，也执行不了同步中的程序代码（经典比喻例子——火车上的卫生间）

同步的前提：

1、必须有两个或者以上的线程

2、必须是多个线程使用同一个锁

3、保证同步中只能有一个线程在运行。

同步的好处：解决了多线程的安全问题

同步的弊端：多个线程需要判断锁，较为消耗资源

package day11_Thread;

class SellTicket2 implements Runnable 
{
	private int tickets = 100;
	Object obj = new Object();
	public void run(){
		while(true){
			//同步代码块
			synchronized (obj) {
				if(tickets>0){
					try {
						Thread.sleep(20);//将会出现线程安全问题
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					System.out.println(Thread.currentThread().getName()+"// sellTicket: "+tickets--);
				}
			}
		}
	}
}
public class Day11_09_ThreadSafety {

	public static void main(String[] args) {
		
		SellTicket2 s = new SellTicket2();
		
		Thread t1 = new Thread(s);
		Thread t2 = new Thread(s);
		Thread t3 = new Thread(s);
		Thread t4 = new Thread(s);
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		
	}

}

-多线程练习3：两个储户分别到银行存款，每次存100元，存3次。实现该程序是否会有线程安全问题，如果有，如何解决？
分析:

1、明确那些代码是多线程运行代码

2、明确共享数据

3、明确多线程运行代码中那些语句是操作共享数据的

package day11_Thread;

class Bank {
	private int sum;
	//Object obj = new Object();
	public synchronized void add(int n){
		//synchronized (obj) {
			sum = sum + n;
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("sum="+sum);
			
		//}
	}
}
class Customer implements Runnable 
{
	private Bank b = new Bank();
	public void run(){
		for(int i=0;i<3;i++){
			b.add(100);
		}
	}
}
public class Day11_11_SynchFunctionPractice {

	public static void main(String[] args) {
		
		Customer c = new Customer();
		Thread t1 = new Thread(c);
		Thread t2 = new Thread(c);
		t1.start();
		t2.start();
	}

}

-理解多线程中同步函数的锁是this

函数需要被对象调用，那么函数都有一个所属对象引用，就是this，所以同步函数使用的锁就是this。

通过程序进行验证：使用两个线程来买票，一个线程在同步代码块中，一个线程在同步函数中，都执行买票动作。

package day11_Thread;

class SellTicket3 implements Runnable 
{
	private int tickets = 100;
	Object obj = new Object();
	boolean flag = true;
	public void run(){
		if(flag){
			while(true){
				// 
				//synchronized (obj) {
				synchronized (this) {
					if(tickets>0){
						try {
							Thread.sleep(10);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()+" -// SychSellTicket: "+tickets--);
					}
				}
			}
		}
		else
			while(true){
				show();
			}
		
	}
	
	//
	public synchronized void show(){//this
		if(tickets>0){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+" -// showSellTicket: "+tickets--);
		}
	}
}

public class Day11_12_SellTicketPractice2 {

	public static void main(String[] args) {
		
		SellTicket3 s = new SellTicket3();
		
		Thread t1 = new Thread(s);
		Thread t2 = new Thread(s);
		t1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		s.flag = false;
		t2.start();
		
	}

}

-学习理解静态同步函数的锁是Class对象——类名.class

通过验证说明同步函数被静态修饰后，所使用的锁不再是this，静态方法中

也不可以定义this；静态进内存，内存中并没有本类对象，只存在该类对应

的字节码文件对象——类名.class

package day11_Thread;

class SellTicket4 implements Runnable 
{
	private static int tickets = 100;
	Object obj = new Object();
	boolean flag = true;
	public void run(){
		if(flag){
			while(true){
				// 
				//synchronized (obj) {
				synchronized (SellTicket4.class) {
					if(tickets>0){
						try {
							Thread.sleep(10);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()+" -// SychSellTicket: "+tickets--);
					}
				}
			}
		}
		else
			while(true){
				show();
			}
		
	}
	
	//
	public static synchronized void show(){//this
		if(tickets>0){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+" -// showSellTicket: "+tickets--);
		}
	}
}

public class Day11_13_StaticSynchFunction {

	public static void main(String[] args) {
		
		SellTicket4 s = new SellTicket4();
		
		Thread t1 = new Thread(s);
		Thread t2 = new Thread(s);
		t1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		s.flag = false;
		t2.start();
		
	}

}

-线程死锁（多线程练习：写一个产生线程死锁的程序）

package day11_Thread;

//学习死锁

class Test implements Runnable {
	private boolean flag;
	public Test(boolean flag){
		this.flag = flag;
	}
	public void run(){
		if(flag){
			synchronized (MyLock.lock1) {
				System.out.println("if lock1");
				synchronized (MyLock.lock2) {
					System.out.println("if lock2");
				}
			}
		}
		else {
			synchronized (MyLock.lock2) {
				System.out.println("else lock2");
				synchronized (MyLock.lock1) {
					System.out.println("else lock1");
				}
			}
		}
	}
}

class MyLock {
	static Object lock1 = new Object();
	static Object lock2 = new Object();
}
public class Day11_15_DeadLockTest {

	public static void main(String[] args) {
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();

	}

}