黑马程序员 JAVA基础--多线程（二）

最新推荐文章于 2024-07-12 17:30:22 发布
最新推荐文章于 2024-07-12 17:30:22 发布
阅读量321 收藏 1
点赞数
分类专栏： 黑马程序员 黑马程序员--多线程 文章标签： 黑马程序员 多线程 线程安全 设计模式 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zewensong/article/details/43496715
版权

                                             

                                                      -----------android培训、java培训、java学习型技术博客、期待与您交流！------------

           在此，分享一下自己学习JAVA的学习心得。有不对的地方请帮忙改正，也希望对想学java的同学有帮助！


JAVA语言基础

多线程（二）

同步函数用的锁：

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

2）静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class。

Java代码：

锁为this时： 
class Ticket implements Runnable
{
	private  int tick = 100;
	Object obj = new Object();
	boolean flag = true;
	public  void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(this)
				{
					if(tick>0)
					{
						try{Thread.sleep(10);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
					}
				}
			}
		}
		else
			while(true)
				show();
	}
	public synchronized void show()//this
	{
		if(tick>0)
		{
			try{Thread.sleep(10);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
		}
	}
}


class  ThisLockDemo
{
	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(Exception e){}
		t.flag = false;
		t2.start();
	}
}
静态的同步方法： 
class Ticket implements Runnable
{
	private static  int tick = 100;
	boolean flag = true;
	public  void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(Ticket.class)
				{
					if(tick>0)
					{
						try{Thread.sleep(10);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
					}
				}
			}
		}
		else
			while(true)
				show();
	}
	public static synchronized void show()
	{
		if(tick>0)
		{
			try{Thread.sleep(10);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
		}
	}
}


class  StaticMethodDemo
{
	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(Exception e){}
		t.flag = false;
		t2.start();


	}
}


同步中出现的死锁现象：

两把锁嵌套使用则有可能出现死锁。

java代码： 

class Test implements Runnable
{
	private boolean flag;//标志
	Test(boolean flag)
	{
	    this.flag = flag;
	}

	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(MyLock.locka)
				{
					System.out.println(Thread.currentThread().getName()+"...if locka ");
					synchronized(MyLock.lockb)
					{
						System.out.println(Thread.currentThread().getName()+"..if lockb");					
					}
				}
			}
		}
		else
		{
			while(true)
			{
				synchronized(MyLock.lockb)
				{
					System.out.println(Thread.currentThread().getName()+"..else lockb");
					synchronized(MyLock.locka)
					{
					   System.out.println(Thread.currentThread().getName()+".....else locka");
					}
				}
			}
		}
	}
}


class MyLock
{
	static Object locka = new Object();
	static Object lockb = new Object();
}

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

同步中嵌套同步： 
<span style="font-size:18px;">class Ticket implements Runnable
{
	private  int tick = 1000;
	Object obj = new Object();
	boolean flag = true;
	public  void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(obj)
				{
					show();
				}
			}
		}
		else
			while(true)
				show();
	}
	public synchronized void show()//this
	{
		synchronized(obj)
		{
			if(tick>0)
			{
				try{Thread.sleep(10);}catch(Exception e){}
				System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
			}
		}
	}
}


class  DeadLockDemo
{
	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(Exception e){}
		t.flag = false;
		t2.start();


	}
}</span>
单例设计模式：

单例设计模式：

1、为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象

2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。


代码体现过程：


1、将构造函数私有化。

2、在类中创建一个本类对象。

3、提供一个方法可以获取到该对象。


饿汉式： 

<span style="font-size:18px;">class Single
{
	private static final Single s = new Single();
	private Single(){}
	public static Single getInstance()
	{
		return s;
	}
}</span>


java代码：

懒汉式： 
class Single
{
	private static Single s = null;
	private Single(){}


	public static  Single getInstance()
	{
		if(s==null)
		{
			synchronized(Single.class)
			{
				if(s==null)
					//--->A;
					s = new Single();
			}
		}
		return s;
	}
}

class SingleDemo 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}



线程通信：

定义：就是多个线程在操作同一个资源，但是操作的动作不同。

例程：
     


知识点：
1）wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中？ 

 1，这些方法存在与同步中。
 2，使用这些方法时必须要标识所属的同步的锁。
 3，锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

2）wait(),sleep()有什么区别？

1，wait():释放cpu执行权，释放锁。
2， sleep():释放cpu执行权，不释放锁。


java代码：

生产者消费者的例子： 

class ProducerConsumerDemo 
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();

		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);

		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);

		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
			//  t1    t2
	public synchronized void set(String name)
	{
		while(flag)
			try{this.wait();}catch(Exception e){}
		this.name = name+"--"+count++;

		System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
		flag = true;
		this.notifyAll();
	}


	//  t3   t4  
	public synchronized void out()
	{
		while(!flag)
			try{wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
		flag = false;
		this.notifyAll();
	}
}

class Producer implements Runnable
{
	private Resource res;

	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			res.set("+商品+");
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;

	Consumer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			res.out();
		}
	}
}


停止线程：

1.定义循环结束标记 

 因为线程运行代码一般都是循环，只要控制了循环即 可。 

2. 使用interrupt（中断）方法。 

该方法是结束线程的冻结状态，使线程回到 运行状态中来。

 注：stop方法已经过时不再使用

知识点：
如何停止线程？

答：只有run方法结束，线程才会停止。开启多线程运行，运行代码通常是循环结构。 只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：

当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类提供该方法 interrupt();

java代码： 

class StopThread implements Runnable
{
	private boolean flag =true;
	public  void run()
	{
		while(flag)
		{
			
			System.out.println(Thread.currentThread().getName()+"....run");
		}
	}
	public void changeFlag()
	{
		flag = false;
	}
}
class  StopThreadDemo
{
	public static void main(String[] args) 
	{
		StopThread st = new StopThread();
		
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);


		t1.setDaemon(true);
		t2.setDaemon(true);
		t1.start();
		t2.start();

		int num = 0;

		while(true)
		{
			if(num++ == 60)
			{
				break;
			}
			System.out.println(Thread.currentThread().getName()+"......."+num);
		}
		System.out.println("over");
	}
}

线程类的其他方法：

1）setPriority(int num) 
2）setDaemon(boolean b) 
3）join() 
4）toString()

java代码： 

class Join implements Runnable
{
	public void run()
	{
	   for (int x = 0; x < 70 ; x++ )
	   {
		   System.out.println(Thread.currentThread().toString()+"++++"+x);//toString();返回该线程的字符串表示形式，包括线程名称、优先级和线程组。 
	       Thread.yield();
	   }
	}
}
class  JoinDemo
{
	public static void main(String[] args) throws Exception
	{
		Join j = new Join();

		Thread t1 = new Thread(j);
		Thread t2 = new Thread(j);

		t1.start();
		//当A线程执行到了B线程的.join()方法是，A就会等待。等B线程都执行完，A才会执行。
		//join可以用来零时加入线程执行。
		//使用时需要对join抛出异常
		t1.join();

		t2.start();
		/*
		  setPriority();设置优先级
		  MAX_PRIORITY  最高优先级
		  MIN_PRIORITY  最低优先级
		  NORM_PRIORITY 默认优先级
		*/
		t2.setPriority(Thread.MAX_PRIORITY);//优先级

		  for (int x = 0; x < 70 ; x++ )
	   {
		   System.out.println(Thread.currentThread().getName()+"++++"+x);
	   }
	   System.out.println("over");
	}
}

















呵呵哒sss
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员-----多线程
cui1kcan2的博客
05-16 524
多线程
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
Java黑马程序员-多线程笔记
luohanisme的博客
10-17 940
哔哩哔哩java黑马视频笔记
黑马程序员---Java基础---多线程
cy912721255的博客
09-27 320
------- android培训、java培训、期待与您交流！ ---------- 一.进程：    1.什么是进程：进程是操作系统的概念，它就是指在操作系统中运行的某个程序；                  每个程序对于操作系统来说都是一个独立的进程，由操作系统管理，分配内存、CPU执行时间.....        2.什么是多进程：是指操作系统可以同时管理多个应用程序的同
黑马程序员---Java从入门到起飞 基础概念
我亦无他，唯手熟尔
06-27 2617
黑马程序员Java教程及资料【全套教程下载】下载地址：https://pan.baidu.com/s/1LxIxcHDO7SYB96SE-GZfuQ提取码：dor4【其他精品教程】下载地址：https://pan.baidu.com/s/1oPdzQ7vO2bivTYtttD1jfw提取码：1234【B站在线观看】地址：https://www.bilibili.com/read/cv9965357【了解Java全体系课程】
黑马程序员——Java基础---多线程详解
Smile_Dark的博客
07-06 665
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------  一，多线程概念          要掌握多线程，首先你需要了解进程和线程的概念，以及两者之间的关系。          1，进程          进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系
黑马程序员——JAVA基础----多线程（二）
Du_jing的博客
11-05 377
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 多线程（二） 01_多线程(单例设计模式) 单例设计模式：保证类在内存中只有一个对象。 如何保证类在内存中只有一个对象呢？ (1)控制类的创建，不让其他类来创建本类的对象。private (2)在本类中定义一个本类的对象。Singl
黑马程序员——Java基础---多线程同步
qq_14926317的博客
12-07 388
理解同步多线程使得多个任务可以并行执行，提高了工作效率。但同时产生了一个问题，因为线程间过快的切换，对资源的同时访问产生拥堵。就好像，大家都要进一个小巷里去，但小巷只容一人通过，结果第一个人刚要进去，第二个人也进去，两个人就挤在了一起，堵住了，出错了。实现要实现线程同步有两种方法： 关键字sunchronized 同步锁Lock 两种方法的使用方式基本相同，具体实现如下。同步关键字：synchron
黑马程序员——Java基础---理解多线程
qq_14926317的博客
12-07 331
——— android培训、java培训、期待与您交流！ ———概念理解多线程，要先知道线程是什么。所谓的线程就是任务，单线程就是一条时间线上只执行一个任务，多线程则是在一条时间线上多任务同时执行。关于线程，还有一个概念叫进程，即从所有要做的任务开始，直到所有任务执行结束，称为一个进程。从理解的角度讲，进程包含着所有线程。而多线程的秘密在于，多线程其实并非真的让所有线程在cpu上同时分配内存并各自进
黑马程序员 JAVA基础 - 多线程（一）
zewensong的专栏
02-03 307
黑马程序员 -----Android培训-----Java基础 -----多线程（一）创建线程的方式、同步
黑马程序员-java多线程技术01
03-25
本教程将聚焦于Java中的多线程技术，以“黑马程序员-java多线程技术01”为学习起点，探讨如何在Java中实现并管理线程。 首先，我们来理解什么是线程。线程是操作系统分配CPU时间的基本单元，一个进程中可以有多个...
传智播客.黑马程序员《Java 基础入门》课后习题答案
06-16
1、 面向对象、跨平台性、健壮性、安全性、可移植性、多线程性、动态性等。 2、 JRE（Java Runtime Environment，Java 运行时环境），它相当于操作系统部分，提供了 Java 程序运 行时所需要的基本条件和许多 Java ...
黑马程序员_张孝祥_Java多线程与并发库
05-17
黑马程序员_张孝祥_Java多线程与并发库,老师讲的非常仔细,老师很有耐心.欢迎大家下载学习.
黑马程序员java基础试题、笔记
01-29
"黑马程序员java基础试题、笔记"这个压缩包资源为Java初学者和希望加入"黑马程序员"培训课程的学员提供了丰富的学习材料。这些资源包括面试问题合集、整理的资料、Android面试题、学员入学面试总结、面试技巧、必须...
常用设计模式
最新发布
u010992421的专栏
07-12 944
设计模式是在软件开发中经过验证的、用于解决常见问题的最佳实践。它们可以帮助开发者设计出更加灵活、可维护和可扩展的软件系统。这些设计模式通常被分为三大类：创建型模式、结构型模式和行为型模式。
GPT带我学-设计模式13-策略模式
qq_37398465的博客
07-09 504
策略模式。
Java学习笔记整理: 关于设计模式解析和设计原则 2024/7/10；
gzx233的博客
07-10 606
Java设计模式设计原则
JavaScript设计模式 -- 代理模式
m0_73280507的博客
07-10 977
@FilePath: \设计模式\代理模式.md* @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE。
黑马程序员java基础
05-18
黑马程序员的Java基础课程主要包括以下内容： 1. Java语言基础：Java语言的发展历史，基本语法结构、数据类型、运算符、流程控制语句等。 2. 面向对象编程：面向对象的基本概念、类与对象、封装、继承、多态等。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值