`
Luob.
  • 浏览: 1588916 次
  • 来自: 上海
社区版块
存档分类
最新评论

java之11天 多线程 (二)

    博客分类：
  • Java
synchronized同步代码块同步函数线程安全死锁 
阅读更多
卖票安全问题 

//线程出现安全问题啦 !!! 卖出了 0  -1 -2 号票了 

class SaleTicket1 implements Runnable{
	private int ticks=100; 
	private long time=1000; //加上这个后 就让安全问题 跟明显了 
	public void run(){  //复写接口中的方法 ,不能抛异常 ,只能try
		while(true){
			if(ticks>0){
				try {
					if(time>0){
						Thread.currentThread().sleep(time);
						time=time-200;
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+".....sale...."+ticks--);
			}
		}
	}
		
}


//使用  synchronized 同步代码块 来解决 
class SaleTicket2 implements Runnable{
	private int ticks=100; 
	private long time=1000; //加上这个后 就让安全问题 跟明显了
	Object obj=new Object();
	
	public void run(){  //复写接口中的方法 ,不能抛异常 ,只能try
		while(true){
			synchronized(obj){ //同步代码块  obj :称为锁 
				if(ticks>0){
					try {
						if(time>0){
							Thread.currentThread().sleep(time);
							time=time-200;
						}
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+".....sale...."+ticks--);
				}
			}
		}
	}
		
}


//使用 synchronized 同步函数 来解决 
class SaleTicket3 implements Runnable{
	private int ticks=100; 
	private long time=1000; //加上这个后 就让安全问题 跟明显了
	//Object obj=new Object();
	
	public void run(){  //复写接口中的方法 ,不能抛异常 ,只能try
		while(true){
			//synchronized(obj){ //同步代码块  obj :称为锁 
				this.show();
			//}
		}
	}
	
	//同步函数 来解决
	public synchronized void show(){
		if(ticks>0){
			try {
				if(time>0){
					Thread.currentThread().sleep(time);
					time=time-200;
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+".....sale...."+ticks--);
		}
	}
		
}



*  同步函数 用的是那一个锁呢 .????(this 锁) 
/**
 * 
 *  函数需要被对象调用, 那么函数都一个所属对象的引用,就是 this
 *  所以同步函数使用的锁是 this
 * 
 *  通过程序来进行验证 同步函数使用的是 this
 *
 *  使用两个程序来买票 
 * 一个线程在不同步代码快找那个
 * 一个线程在同步函数中
 * 都在执行买票动作.
 *
 */
class SaleTicket implements Runnable{
	private int ticks=1000; 
	private long time=10; //加上这个后 就让安全问题更明显了
	Object obj=new Object();
	boolean flag=true;
	public void run(){  //复写接口中的方法 ,不能抛异常 ,只能try
		if(flag){
			while(true){
				/**
				 * 发现 使用 obj 的时候 卖出的票 出现了  0  -1 -2  ,说明同步没有成功,  
				 * 找原因发现, 不满足线程同步第二个条件, 就是使用的不是同一个锁,
				 *  把 obj 换成 this 试试  发现 结果正确了 由此 
				 *  
				 */
				synchronized(this){  //obj -->this
					if(ticks>0){
						try {
							if(time>0){
								Thread.currentThread().sleep(time);
								///time=time-200;
							}
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()+".....sale...."+ticks--);
					}
				}
			}
		}else
			while(true)
					this.show();
	}
	
	/*
	 * 同步函数 用的是那一个锁呢 .
	 * 
	 * 函数需要被对象调用, 那么函数都一个所属对象的引用,就是 this
	 * 所以同步函数使用的锁是 this
	 * 
	 */
	public synchronized void show(){
		if(ticks>0){
			try {
				if(time>0){
					Thread.currentThread().sleep(time);
					//time=time-200;
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+".....sale...."+ticks--);
		}
	}
		
}



main Test 
public class ThreadDemo1 {
	public static void main(String[] args) {
		SaleTicket t1=new SaleTicket();
		
		Thread th1=new Thread(t1);  //创建了一个线程 并将Runnable 子类对象给  Thread 构造函数
		Thread th2=new Thread(t1); 
		//Thread th3=new Thread(t1);  
		//Thread th4=new Thread(t1);  
		
		th1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		t1.flag=false;
		th2.start();  
		//th3.start();
		//th4.start();
		
		
//测试  同步函数使用的锁时候  ,只需要用 两个线程就可以了 其他的 4个 来测试 .
	}

}


静态同步函数 (Class 锁) 

/**
* 如果同步函数被静态就是后,使用的锁是什么呢?
* 通过验证,发现 不在是 this ,因为静态中不可以定义 this
*
* 静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象
* 类名.class  该对象的类型是Class 
*
* 通过下面的测试 发现 
* 静态的同步方法,使用的锁是该方法所在类的字节码文件对象, 类名 .calss
*
*/
class SaleTicket implements Runnable{
	private static int ticks=1000; 
	private static long time=10; //加上这个后 就让安全问题更明显了
	//Object obj=new Object();
	boolean flag=true;
	public void run(){  //复写接口中的方法 ,不能抛异常 ,只能try
		if(flag){
			while(true){
				synchronized(SaleTicket.class){  //obj(不安全卖出了 0 号票) -->this(不安全卖出了 0 号票)--->SaleTicket.calss (安全了 发现从此没有卖出 0号票了)
					if(ticks>0){
						try {
							if(time>0){
								Thread.currentThread().sleep(time);
							}
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()+".....sale...."+ticks--);
					}
				}
			}
		}else
			while(true)
					this.show();
	}
	
	//静态 同步方法
	public static synchronized void show(){
		if(ticks>0){
			try {
				if(time>0){
					Thread.currentThread().sleep(time);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+".....sale...."+ticks--);
		}
	}
		
}

public class ClassLoaclDemo {
	public static void main(String[] args) {
		SaleTicket t1=new SaleTicket();
		
		Thread th1=new Thread(t1);  //创建了一个线程 并将Runnable 子类对象给  Thread 构造函数
		Thread th2=new Thread(t1); 
		
		th1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		t1.flag=false;
		th2.start();
		
	}

}


单例模式 
/**
 * 单例模式 
 * 
 *  //饿汉式
 *  class Single{
 *    private static final Single s=new Single();
 *    private Single();
 *    public static Single getInstance(){
 *    	return s;
 *    }
 *  }
 *  
 *  
 *  //懒汉式
 *  class Single{
 *   private static Single s=null;
 *   private Single(){}
 *   public static Single getInstance(){
 *     if(s=null)
 *        s=new Single();
 *     return s;
 *   }
 *   
 *   
 *  
 *  }
 *  
 * 
 *
 */

//懒汉式 加入 同步 效率比较低效
class Single{
	private static Single s=null;
	private Single(){}
	//使用 同步函数
	public static synchronized Single getInstance1(){
		if(s==null)
			s=new Single();
	   return s;
	}
	
	//使用 同步代码快
	public static Single getInstance(){
		if(s==null){  //使用双重判断 增加  懒汉式 的效率
			synchronized(Single.class){
				if(s==null)
					s=new Single();
			}
		}
	   return s;
	}
	
}

public class SingleDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Single s =Single.getInstance();
	}

}


死锁1 
/**
 * 死锁
 * 通常,是同步中嵌套同步,但是锁不同
 *
 */

class SaleTicket implements Runnable{
	private int ticks=1000; 
	private long time=10; 
	Object obj=new Object();
	boolean flag=true;
	public void run(){  
		if(flag){
			while(true){
				synchronized(obj){  //同步代码块 里面有同步 函数
					show();   //this
				}
			}
		}else
			while(true)
					this.show();  //this 
	}
	
	//同步函数里面有 同步代码块 
	public synchronized void show(){//使用的是 this 
		synchronized(obj){    //这里确使用的  obj
			if(ticks>0){
				try {
					if(time>0){
						//Thread.sleep(time);
						Thread.currentThread().sleep(time);
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+".....sale...."+ticks--);
			}
		}
	}
		
}

public class DeadLocalDemo {

	public static void main(String[] args) {
		SaleTicket t1=new SaleTicket();
		
		Thread th1=new Thread(t1);  //创建了一个线程 并将Runnable 子类对象给  Thread 构造函数
		Thread th2=new Thread(t1); 
		//Thread th3=new Thread(t1);  
		//Thread th4=new Thread(t1);  
		
		th1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		t1.flag=false;
		th2.start();
		//th3.start();
		//th4.start();
	}

}


死锁2 
**
 * 请写一个简单的死锁例子
 */
class Test implements Runnable{
	private boolean flag;
	Test(boolean flag){
		this.flag=flag;
	}
	
	public void run(){
		if(flag){
			synchronized (MyLock.locka) {
				System.out.println("if locka");
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				synchronized (MyLock.lockb) {
					System.out.println("if lockb");
				}
			}
		}else{
			synchronized (MyLock.lockb) {
				System.out.println("else lockb");
				synchronized (MyLock.locka) {
					System.out.println("else locka");
				}
			}
		}
	}
	
	
}
class MyLock{
	static Object locka=new Object();
	static Object lockb=new Object();
	
}

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

}
0
顶
4
踩
分享到：
| java之11天 多线程 (一)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java教程-每日一课，27天java从入门到进阶

    第11天：API类 第12天：字符串王者地位 第13天：算法工具类包装类 第14天：正则及其他类 第15-18天：数组到集合 第19天：文件操作IO 第20、21天：IO流文件操作类图 第22天：其他流 第23天：多线程 第24天：多线程...

    java视频教程_黑马Java零基础辅导班[第二期]11天课件源码

    《Java编程学习之旅：黑马Java零基础辅导班[第二期]11天课件源码解析》 在Java开发的世界里，扎实的基础是每一位程序员的基石。本篇将围绕"java视频教程_黑马Java零基础辅导班[第二期]11天课件源码"这一主题，深入...

    尚硅谷_宋红康_第8章_多线程.pdf

    ·基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 ·课程中，Eclipse和IDEA这两种企业一线开发环境都使用到了 3.技术讲解更深入、更全面： ·课程共30天，715个知识视频小节，涉及主流Java使用的...

    java100天速成

    6. **多线程**：Java对多线程的支持非常强大，你需要学习如何创建和管理线程，理解同步与互斥，以及线程池的概念，这对提升程序性能有很大帮助。 7. **网络编程**：Java的Socket编程能让你构建网络应用程序，理解...

    韩顺平30天学java

    9. **多线程**：理解并发编程的基础，如线程的创建、同步机制（synchronized关键字、wait/notify等）和线程池的使用。 10. **文件和目录操作**：学习如何在Java中创建、读取、修改和删除文件及目录。 11. **网络...

    满天星星java源程序

    8. **多线程**：Java内置了对多线程的支持，包括线程的创建、同步和通信。 9. **IO与NIO**：Java I/O流系统和新引入的非阻塞IO(NIO)模型，为高性能网络编程提供基础。 10. **异常处理**：学习如何使用try-catch-...

    21天学好JAVA

    7. **多线程编程**：了解线程的概念，学习Thread类和Runnable接口，掌握同步和异步操作，以及线程间的通信。 8. **JAVA Swing和JavaFX**：学习如何使用JAVA创建图形用户界面（GUI），掌握Swing组件库的使用，或者更...

    21天学通java的源代码

    6. 多线程：Java内置了对多线程的支持，使得开发并发应用变得相对简单。 7. 安全性：Java有严格的安全模型，防止恶意代码对系统造成损害。 在《21天学通Java》这本书中，读者可以接触到以下核心知识点： 1. Java...

    21天精通java源代码

    6. **多线程**：Java提供了对多线程的支持，理解线程的创建、同步和通信，可以实现高效的并发处理。 7. **反射机制**：反射是Java的一大特色，它允许在运行时检查类、接口、字段和方法的信息，甚至动态调用方法。 ...

    27天成为Java大神

    6. **多线程**：Java内置了对多线程的支持，包括Thread类、Runnable接口，以及同步控制方法（如synchronized关键字、wait()、notify()和notifyAll()）。 7. **反射API**：Java反射机制允许在运行时动态地获取类的...

    21天学会Java--教案

    Java支持多线程编程，这使得程序可以同时执行多个任务。学习者将了解线程的概念，如何创建和管理线程，以及如何使用同步机制避免并发问题。 第18-21天：高级话题 这部分可能涵盖反射、泛型、枚举、注解等Java的高级...

    java基础18天Typora笔记

    多线程编程是Java的一个重要特性，通过实现Runnable接口或继承Thread类创建线程。了解并发控制（synchronized关键字、wait/notify机制）、线程状态以及线程池的概念。 9. **文件与文件系统** 学习File类用于文件...

    21天学通Java 20小时多媒体语音视频教学

    《21天学通Java》是一本面向初学者的Java编程教材，旨在通过21天的学习计划，让读者快速掌握Java编程基础。20小时的多媒体语音视频教学则为学习者提供了更为直观和生动的学习方式，使理论知识与实践操作相结合，加深...

    21天学会java光盘电子教案（PPT）.

    9. **多线程**：Java内置了对多线程的支持，你可以通过实现Runnable接口或继承Thread类来创建线程。 10. **Swing和JavaFX**：对于图形用户界面（GUI）开发，Java提供了Swing和JavaFX库。这两个库包含了各种组件和...

    21天学java源代码

    9. **多线程**：Java内置了对多线程的支持，学习者需要理解线程的创建、同步、生命周期管理等概念。 10. **文件和目录操作**：Java提供了File类来处理文件和目录，包括创建、删除、重命名等操作。 11. **Swing和...

    21天学通Java.第7版-中文版-良心积分价

    10. **多线程**：Java内置了对多线程的支持，通过实现Runnable接口或继承Thread类来创建线程。了解线程的同步和通信机制，如synchronized关键字、wait()、notify()和notifyAll()方法。 11. **文件和目录操作**：...

    Java35天详细讲义

    11. **多线程**：讲解线程的创建和管理，同步机制（如synchronized关键字和wait/notify机制）以及线程池的使用。 12. **接口与抽象类**：对比接口和抽象类，理解它们在设计中的作用。 13. **反射与注解**：介绍...

    21天自学速成 Java 语言 电子书

    11. **多线程**：学习如何创建和管理线程，同步机制（synchronized关键字、wait()、notify()、notifyAll()），以及线程池的使用。 12. **网络编程**：了解套接字（Socket）编程，包括TCP和UDP通信。 13. **Java...

    java视频教程_黑马Java零基础辅导班[第二期]08天课件源码

    11. **多线程**：Java内置了对多线程的支持，通过Thread类或实现Runnable接口创建并管理线程，理解同步和互斥的概念，能够编写并发程序。 12. **异常与日志**：在实际开发中，良好的异常处理和日志记录能帮助定位和...

    Java2 编程21天自学通

    11. **多线程**：掌握线程的创建与同步，包括Thread类、Runnable接口，以及synchronized关键字、wait()和notify()方法。 12. **IO流和NIO**：了解Java的IO流体系，以及New IO (NIO) 提供的非阻塞I/O操作。 13. **...

Magicbox
Global site tag (gtag.js) - Google Analytics