线程，死锁

最新推荐文章于 2017-11-10 11:47:59 发布
最新推荐文章于 2017-11-10 11:47:59 发布
阅读量210 收藏
点赞数
分类专栏： JAVASE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjx568135132/article/details/76022257
版权
                                                                                            

   一. 线程之间的通信

        1.1wait()等待
             将当前线程从运行状态便到阻塞状态（释放对象锁）
       1.2 noytify()
             只唤醒一个对应对象所的一个线程
       1.3 notifyAll()

            唤醒全部对应对象所的线程

         

public class Demo01 {

	public static void main(String[] args) {
		/*线程之间的通信：多线程之间的
		 * wait()等待       将当前线程从运行状态便到阻塞状态（释放对象锁）
		 * noytify()  只唤醒一个对应对象所的一个线程 
		 * notifyAll() 唤醒全部对应对象所的线程
		 * 
		 * 上面三个方法：是属于Object类的，不是线程特有的方法
		 *
		 *上诉方法要在同步代码里面使用才有意义
		 */
		MyThread13 th=new MyThread13();
		try {
			th.notify();
		} catch (Exception e) {
			// TODO: handle exception
		}
		
	}
}
class MyThread13 extends Thread{
	
}


    二.线程安全问题

       

public class LockDemo02 {
	public static void main(String[] args) {
		/*线程安全问题：仅限于多线程
		 * 锁对象的概念：
		 * 	在JAVA中每一个对象都有一个内置的对象锁，并且整个锁只有一把钥匙。
		 * 这就决定了当一个线程获取了该对象锁的时候别的线程无法再去获取，只有当获取对象锁的线程释放了锁以后才能去使用。
		 * 
		 * 常用两种锁对象的方式：
		 * 	一种是对象，
		 * 	一种是class文件 （类.class 或者对象.getClass()）
		 * 
		 * 1.同步代码块    本质锁对象
		 * 2.同步方法 （普通的方法  以及静态方法）
		 * 			同步普通方法锁的也是对象
		 * 			同步静态方法锁的是     字节码文件 （.class）
		 * 
		 */
		Mythread11 th=new Mythread11();
		Thread th1=new Thread(th,"窗口1");
		Thread th2=new Thread(th,"窗口2");
		Thread th3=new Thread(th,"窗口3");
		th1.start();
		th2.start();
		th3.start();
	}

}
class Mythread11 implements Runnable{
	private int ticket=50;
	@Override
	public void run() {
//			while(true){
//			  synchronized (Mythread11.class) {//同步代码块
//				if(ticket>0){
//				  try {
//					Thread.sleep(200);
//				  } catch (Exception e) {
//					  e.printStackTrace();
//				  }
//				System.out.println(Thread.currentThread().getName()+"D360还剩"+ticket+"张票");
//				ticket--;
//			     }
//				else{
//					System.out.println("很遗憾，没票了");
//					break;
//				}
//		   }
//	 
//    	}
		method(); //调用同步方法
	}
	//同步方法   同步可以定义在 自定义的类当中，不限于线程类
	public synchronized void method(){
		while(true){
			  synchronized (Mythread11.class) {//同步代码块
				if(ticket>0){
				  try {
					Thread.sleep(200);
				  } catch (Exception e) {
					  e.printStackTrace();
				  }
				System.out.println(Thread.currentThread().getName()+"D360还剩"+ticket+"张票");
				ticket--;
			     }
				else{
					System.out.println("很遗憾，没票了");
					break;
				}
		   }
	 
  	}
	}
}


       2.1仅限于多线程

       2.2 锁对象的概念
            在JAVA中每一个对象都有一个内置的对象锁，并且整个锁只有一把钥匙。
* 这就决定了当一个线程获取了该对象锁的时候别的线程无法再去获取，只有当获取对象锁的线程释放了锁以后才能去使用。
                一种是对象
                    常用两种锁对象的方式:
                一种是class文件 （类.class 或者对象.getClass()）
       2.3 线程退让

            

public class YieldDemo {

	public static void main(String[] args) {
		/*线程退让
		 * 线程的优先级:默认优先级为5
		 * 注意：线程在执行过程中不能改变优先级，必须在线程开启之前设置优先级
		 * 范围：1-10数字越大优先级越大
		 */
		MyThread10 th=new MyThread10();
		th.setName("线程一");
		th.setPriority(Thread.MAX_PRIORITY); //最大优先级
		System.out.println(th.getPriority());
		MyThread10 th1=new MyThread10();
		th1.setName("线程二");
		th1.setPriority(Thread.MIN_PRIORITY);
		th.start();
		th1.start();
	}
}
class MyThread10 extends Thread{
	int i=1;
	@Override
	public void run() {
		while(i<100){
			if(i==50){
				Thread.yield(); //线程让步
			}
			System.out.println(Thread.currentThread().getName()+"=="+i);
			i++;
		}
	}
}

       线程的优先级

                默认优先级为5
                注意：线程在执行过程中不能改变优先级，必须在线程开启之前设置优先级
                范围：1-10数字越大优先级越大

   

      三.生产者和消费者模式

       3.1 Clerk     

//商店类
public class Clerk {
	/*
	 * 主要负责两个内容：
	 * 1.有货通知消费者去买东西
	 *    1.1
	 * 2.没货的时候通知生产者生产东西
	 * 	  2.1
	 * 
	 * 
	 * wait:在当前运行线程调用的时候回主动释放掉对象锁并进入到阻塞的状态，如果该线程想恢复到就绪状态，则必须等到同一个对象
	 * 调用notify/notifyAll()方法才行
	 * 
	 * 概念：线程池
	 */
	private int goodsNum=20;  //默认商店目前有最大持有商品数
	
	//生产者的
	public synchronized void add(){
		if(goodsNum>=20){//货满的时候
			System.out.println("sorry,商店期货过多，请稍停生产");
			try {
				this.wait();//让生产者等地
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
			++goodsNum;
			System.out.println("生产了第"+goodsNum+"个商品给"+Thread.currentThread().getName());
			this.notify();//唤醒通知生产者可以生产商品
		}
	}
	
	//消费者
	public synchronized void sell(){
		if(goodsNum<=0){
			System.out.println("sorry,商店没货 了");
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
			System.out.println("卖了第"+goodsNum+"个商品给"+Thread.currentThread().getName());
			goodsNum--;
			this.notify();
		}
	}

        3.2 Consumer

           

public class Consumer implements Runnable {
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		super();
		this.clerk = clerk;
	}

	@Override
	public void run() {
		while(true){
		try {
			Thread.sleep((int)(Math.random()*1000));
		} catch (Exception e) {
			// TODO: handle exception
		}
		clerk.sell();
	}
	}
}

        3.3 Productor

         

//生产者一个线程类
public class Productor implements Runnable{
	private Clerk clerk;
	
	public Productor(Clerk clerk) {
		super();
		this.clerk = clerk;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true){
		try {
			Thread.sleep((int)(Math.random()*1000));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		clerk.add();//
		}
	}

}

       3.4 TestDemo

       

public class TestDemo {

	public static void main(String[] args) {
		/*
		 * 
		 *测试类 
		 * 
		 */
		Clerk clerk=new Clerk();
		Productor pro =new Productor(clerk);
		Consumer con=new Consumer(clerk);
		Thread th1=new Thread(pro,"生产者一");
		Thread th2=new Thread(con,"消费者一");
		th1.start();
		th2.start();
	}

}


   四. 死锁和同步静态方法锁

       4.1 死锁
            当一个线程拥有另一个线程的资源所得时候，而另一个也拥有该线程的资源所。
* 彼此都必须在获得对方资源锁的时候才能持续运行。

 * 当两方都不退让的时候，就会陷入一种僵持状态----死锁

      

public class DeadLockDemo {

	public static void main(String[] args) {
		/*死锁：当一个线程拥有另一个线程的资源所得时候，而另一个也拥有该线程的资源所。
		 * 彼此都必须在获得对方资源锁的时候才能持续运行。
		 * 当两方都不退让的时候，就会陷入一种僵持状态----死锁
		 * 
		 * 产生的前提是：
		 * 		线程之间持有相同的对象锁，获取对象锁的顺序反过来。。
		 */
		Battery battery =new Battery("南孚");
		
		Controler controler=new Controler("遥控器");
		
		//
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				synchronized (controler) { //有遥控器没电池
					System.out.println("小妹啊，我手里拿着遥控器，你不给电池我我就不给遥控器你");
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					//在等待电池
					synchronized (battery) {
						System.out.println("哈哈哈哈，终于可以看喜洋洋了");
						
					}
				}
				
			}
		},"小明").start();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				synchronized (battery) {
					System.out.println("哥哥，我手里拿着电池，你不给遥控器我就不给电池你，哼。。。");
					try {
						Thread.sleep(1000);
					} catch (Exception e) {
						// TODO: handle exception
					}
					synchronized (controler) {
						System.out.println("还是哥哥好，终于给遥控器我了，哈哈哈哈。。");	
					}
				}
			}
		} ,"小红").start();
	}
}
//电池类
class Battery{
  public String name;

public Battery(String name) {
	super();
	this.name = name;
   }	
}
//遥控器类
class Controler{
	public String name;
	public Controler(String name) {
		super();
		this.name = name;
   }
}


         4.1.1 产生的前提是：

 *     线程之间持有相同的对象锁，获取对象锁的顺序反过来。


       4.2 同步静态方法锁
            同步静态方法锁的是什么？

       * 锁的是字节码文件，不是对象

          

public class StaticDemo {

	public static void main(String[] args) {
		/*同步静态方法锁的是什么？
		 * 锁的是字节码文件，不是对象
		 * 
		 * 
		 * 
		 */
		Test test1=new Test();
		Test test2=new Test();
		MyThread12 th1=new MyThread12(test1);
		MyThread12 th2=new MyThread12(test2);
			th1.setName("线程一");
			th2.setName("线程二");
		    th1.start();
		    th2.start();
		
	}
}
class Test{
	//同步静态方法
	public synchronized static void fun(){
		System.out.println(Thread.currentThread().getName()+"进入fun()方法");
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"离开fun()方法");
	}
	public void fun2(){
		fun();  //调用同步静态方法
	}
}
class MyThread12 extends Thread{
	private Test test;

	public MyThread12(Test test) {
		super();
		this.test = test;
	}
	@Override
	public void run() {
		test.fun2(); //
	}
}


   

星锅
关注
专栏目录
Java实现线程死锁
01-20
　春节的时候去面试了一家公司，笔试题里面有一道是使用简单的代码实现线程的‘死锁’，当时没有想到这道题考的是Synchronized关键字，于是自己定义了两个资源模拟了一下。后面想想肠子都悔青了，于是自己在电脑上...
线程死锁示例
01-18
本资源为多线程中，多线程共享资源，出现死锁的情况。浅显易懂
iOS中的线程死锁实例详解
01-04
什么是线程死锁 是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。 线程死锁怎么发生 发生死锁的情况一般是两个对象的锁相互等待造成的。 死锁...
Java多线程死锁示例
08-27
在本示例中，我们将深入探讨Java多线程死锁的概念，并通过一个具体的代码示例来理解其工作原理和避免策略。 首先，我们来看标题中的关键点——“Java多线程死锁示例”。死锁是多线程编程中的一种异常状态，通常发生...
线程死锁的例子
08-30
线程死锁是多线程编程中一个严重的问题，它发生在两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。这个概念在计算机科学中尤为重要，因为并发执行是提高系统性能的关键手段，但如果不妥善处理，死锁...
Java运算符和原反补码
梦月如风的博客
04-30 804
Java运算符   一．算术运算符 1.  +  -  *   /   %    ++   -- 2.  d=++c;       //先递增，再赋值      d=c++;       //先赋值，在递增   二．赋值运算符 1.  =   +=   -=   *=  /=   %=         //遵循自右向左的结合性   三．逻辑运算符   运算符
方法的递归调用
梦月如风的博客
05-14 790
方法的递归调用        概念：属于方法的自身调用        例子： 1.阶乘的计算           // 10! // 递归 ，方法本身调用方法本身 // 注意，防止死循环 设计好出口   System.out.println(getNum(5)); //getNum(5) //5*getNum(4) //5*4*getNum(3) //5*4*3*getNu
java环境变量设置常见的问题
梦月如风的博客
11-10 432
一、安装JDK 1.8          在Oracle官网下载好1.8的jdk，然后路径我是直接在默认下安装了。安装jdk的时候jre也会一起装下来。 二、配置环境变量         打开计算机系统系统属性-----------高级系统配置-------------环境变量-----------在系统变量下新建，         2.1  新建变量名为JAVA_
JAVA基本结构程序
梦月如风的博客
05-08 351
一．流程控制语句1.顺序控制语句 （1）表达式语句 表达式； （2）空语句：只一个分号（；） （3）符合语句：用大括号扩起来的语句序列{ [变量声明或常量声明]； 语句序列； }2.分支语句 1.if 语句 If（布尔表达式）{ 语句序列 } 2.If…….else语句 If（布尔表达式）{ 语句序列1 } else{ 语句序列2
Java 面向对象_5
梦月如风的博客
07-11 332
JAVA面向对象_5 一.多态     1.概念         1.字面上，事物的多种形态         2.本质：一个类的对象在编译的时候并不明确使用哪个对象，只有在运行的时候才确定，父类引用数据类型指向子类的对象     2.作用：         提升对象的作用范围     3.条件         3.1向上转型         3.2必须有继承或者实现关系
Java IO流
梦月如风的博客
07-21 282
JAVA IO流 一.File类         在整个IO包中，唯一与文件本身有关的类就是File类        1.1 File类的常用方法和常量             pathSeparator  //表示路径的分隔符（windows是：“；”）             separator   //表示路径的分隔符（widows是：“\”）      
Java面向对象_4
梦月如风的博客
06-29 266
Java面向对象_4 一.instance of关键字：           判定一个对象是否由某个类（也包括接口）实例化出来，或者为该类的子类 二.final关键字：     最终的         修饰的变量，不能够在本类和类外面进行二次修改         不同作用域的局部变量之间没有关系          两种思路：1.设置为私有属性但不提供公共方法给外界访问       
Java面向对象_3
梦月如风的博客
06-28 266
Java面向对象_3 一.方法的重写和重载     方法的重写：  当父类的方法内容不满足子类的需求，需要对父类的方法进行重写。  1.两个类之间存在继承或者实现的关系  2.方法的名字和参数根父类的一样。  3.重写后该方法的权限修饰符必须要大于或等于父类该方法的权限修饰符  4.子类重写的方法返回值要大于或等于父类的方法权限修饰符  5.重写后该方法抛出的异常必须要小于或等于父
JAVA面向对象
梦月如风的博客
06-27 253
面向对象 一.面向对象的散打特征：     1.封装         就是对象的成员变量和成员方法被封装在对象中。     2.继承         子类直接使用父类中非私有的属性和方法的形式     3.多态         多态是指同一名称的方法或变量具有多种可能的含义 二.类及其成员     1.成员变量     2.功能方法（函数）         成员方法
JSON和GSON
梦月如风的博客
07-24 248
JSON和GSON     一.JSON         结构清晰   数据传输量小         有两类             对象                 （name age）{}             数组                 数组[{},{},{},{}]      public class Demo01 { //JSON： //结构清
包装类和正则表达式
梦月如风的博客
07-14 246
一. Integer,String 相关:         1).Integer 是int的包装类。         2).String str1=”abc”;//”abc”（常量池），首先去常量池中查看是否“abc”，如果没有生成“abc”   String str2=new String(“abc”);     //str2 栈“abc”   堆    二. 正则表达式
数组
梦月如风的博客
06-27 220
数组    1.一维数组       数据类型 [] 数组名=new 数据类型[长度]；       存储一组相同的数据类型。     2.数组[引用数据类型]       Person persons=new Person[]{p1,p2,p3};     3.数组的排序         ①.冒泡排序         ②.选择排序         ③.插入排序    
反射和注解
梦月如风的博客
07-25 215
注解和反射    一. 反射              public class Demo01 { public static void main(String[] args) { //类---〉对象 Person person=new Person("Wan",11); Class clazz=person.getClass(); System.out.prin
简单线程死锁检测技术及VC++实现
"一种简单的线程死锁检测方法及其VC++应用" 线程死锁是多线程编程中常见的问题，当两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉它们都无法推进各自的执行状态。这种情况下，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值