黑马毕向东Java课程笔记（day11）:多线程（第一部分）——进程与线程+线程创建+线程安全与同步代码块+同步锁/死锁

最新推荐文章于 2019-09-07 15:26:50 发布
最新推荐文章于 2019-09-07 15:26:50 发布
阅读量387 收藏 1
点赞数
分类专栏： Java资料 文章标签： java多线程 黑马程序 毕向东 java入门
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LKJgdut/article/details/99684078
版权
本文介绍了Java多线程的基础知识，包括进程与线程的概念，线程的创建（继承Thread类和实现Runnable接口），线程安全问题及同步代码块的使用。详细探讨了synchronized关键字的工作原理，以及多线程可能导致的死锁问题。此外，还提到了线程调度和线程状态，以及Thread和Runnable的区别。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  • 多线程好文：添加链接描述
  • 锁机制：synchronized、Lock、Condition、volatile（原子性可见性）——参考添加链接描述
    1、进程与线程概述
      首先，对于CPU执行每一个程序，其实都是在快速切换程序，一个核的CPU只能同时执行一个任务，因为CPU切换很快，我们反应不过来。
      所谓进程，字面意思上理解就是“是一个正在执行中的程序”。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。对于一个进程，它还有可能分为多条执行路径（如进程迅雷下载可能分为多路径进行下载，这多条路径同时发送下载请求到服务端，这样就可以多路径同时下载，效率更高），这每一条执行路径就称为线程。
      也就是说，线程是进程中的内容，每一个应用程序（进程）至少有一个线程，因为线程是进程独立的控制单元，或者说是执行路径，线程在控制着进程的执行。（结合视频11-1，10分30秒开始处对进程线程进行理解）
      对于java，它有一个编译进程和一个运行进程。Java 虚拟机启动的时候会有一个进程java.exe，该进程中至少一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程。其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。（一个进程中有多个线程在执行，这就是多线程）。
    关于进程与线程的深入理解，参考如下文章：
    深入理解进程线程

2、线程的创建
  我们写代码的时候也想自定义创建一些线程，让某些代码可以同时执行。
  线程对象是可以产生线程的对象。比如在Java平台中Thread对象，Runnable对象。线程，是指正在执行的一个指点令序列。在java平台上是指从一个线程对象的start()开始，运行run方法体中的那一段相对独立的过程。相比于多进程，多线程的优势有：

  1. 进程之间不能共享数据，线程可以；
  2. 系统创建进程需要为该进程重新分配系统资源，故创建线程代价比较小；
  3. Java语言内置了多线程功能支持，简化了java多线程编程。
      如何在自定义的代码中，自定义一个线程呢？java已经提供了对线程这类事物的描述，就是Thread类。

2.1、继承Thread类创建线程类
  通过继承Thread类创建线程类的具体步骤和具体代码如下：
1）定义一个继承Thread类的子类，并重写该类的run()方法；
  目的：将自定义代码存储在run方法，让线程运行。

2）创建Thread子类的实例，即创建了线程对象；

3）调用该线程对象的start()方法启动线程。
  该方法两个作用：启动线程，调用run方法。

class Demo extends Thread
{
	public void run()
	{
		System.out.println("thread run");
	}
}

public class ThreadDemo
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();//建立好一个继承Thread类的类Demo的对象，相当于创建好一个线程
		d.start();
		//start()：使该线程开始执行，Java 虚拟机调用该线程的 run 方法。 
//		结果是两个线程并发地运行，当前线程（从调用返回给 start 方法）和另一个线程（执行其 run 方法）。 
		d.run();//直接写d.run()，这就相当于没有开启另一个线程，而是直接调用的run()方法，就是直接执行完run()，再执行下面代码，只有一个主线程。

		Thread t = new Thread();//这样也相当于创建一个线程
		t.start();//开启线程，start()调用run()非法
		//但是这样我们不知道要运行什么代码，因为run()非法没有重写，没有运行内容
		//而且开启线程是为了运行自己制定的代码，上面这样设置线程没有意义
	}
}
//结果是：thread run

  再看下面这个例子，我们发现2个线程（主线程以及Demo线程）是穿插打印的。（参考视频11-2的11分30秒开始处的解释）这个结果说明2个线程在同时执行。（一核CPU在一个时候只能执行一个进程，看起来是在同时执行多个进程，其实CPU是在切换进程，更细一点说，CPU是在切换线程）如果CPU有多核，就可以达到同时执行的效果。

class Demo extends Thread
{
	public void run()
	{
		for(int x=0 ; x<60 ; x++)
			System.out.println("thread run"+x);
	}
}

public class ThreadDemo
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		d.start();
		
		for(int x=0 ; x<60 ; x++)
			System.out.println("demo run"+x);
	}
}

在这里插入图片描述
  发现运行结果每一次都不同。因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行。明确一点，在某一个时刻，只能有一个程序在运行(多核除外)，cpu在做着快速的切换，以达到看上去是同时运行的效果。我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
  这就是多线程的一个特性：随机性，谁抢到谁执行，至于执行多长，cpu说的算。
  为什么要覆盖run方法呢？Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。

  练习：

class Demo extends Thread
{
	private String name;
	Demo(String name)
	{
		this.name = name;
	}
	public void run()
	{
		for(int x=0 ; x<60 ; x++)
			System.out.println(name+"运行"+x);
	}
}

public class ThreadDemo
{
	public static void main(String[] args) 
	{
		//注意，不需要创建多个Demo继承Thread，因为只要new一个Demo的对象就是创建一个新的线程
		Demo d1 = new Demo("线程一");
		Demo d2 = new Demo("线程二");
		d1.start();
		d2.start();
				
		for(int x=0 ; x<60 ; x++)
			System.out.println("主线程运行"+x);	
	}
}

  接下来说一下线程运行状态，线程运行有4种常见状态（当然还有其他状态，如阻塞）：被创建，运行，冻结，消亡，这4种状态之间的关系如下图：（参考视频11-5的解释）
在这里插入图片描述
  需要说明的是，运行状态具有运行资格，也有执行权，当CPU挂起这个线程，进入阻塞状态，阻塞状态具有运行资格（可以运行），但是没有执行权（CPU执行它），当CPU又进入这个线程使其执行，又会从阻塞状态回到运行状态。
  另一方面，运行状态可以通过sleep(time)或者wait()进入冻结状态，sleep(时间)到就会返回，而wait()需要notify()方法使其返回。冻结状态放弃了运行资格（CPU的执行权在这个线程手上，是这个线程自己不想执行，放弃资格，进入冻结状态的时候他也有执行权，因为CPU在这个线程）。冻结状态返回的时候会先返回阻塞状态（有运行资格，没有CPU执行权），因为它返回的时候又取回自己的运行资格，但是它冻结返回时，不知道CPU还在不在这个线程执行。所以先回阻塞，如果CPU在这个线程执行，就恢复执行权返回运行状态；如果CPU不在这个线程，就现在阻塞状态等待CPU回来给他赋予执行权。

线程的五大状态及其转换
1、resume与suspended一起使用， wait与notify(notifyAll)一起使用， sleep会让线程暂时不执行 。	suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态。

2、线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。
	1）新建状态(New)： 当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码
	2）就绪状态(Runnable)
	一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
	处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。
	3）运行状态(Running)
	当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.
	4）阻塞状态(Blocked)
	线程运行过程中，可能由于各种原因进入阻塞状态: 1>线程通过调用sleep方法进入睡眠状态； 2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者； 3>线程试图得到一个锁，而该锁正被其他线程持有； 4>线程在等待某个触发条件； ......
	所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间， 进入运行状态。
	5）死亡状态(Dead)
	有两个原因会导致线程死亡：
	i) run方法正常退出而自然死亡，
	ii) 一个未捕获的异常终止了run方法而使线程猝死。 为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是 可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了， 则返回false.

在这里插入图片描述

  当我们创建的线程一多，我们就需要一些标识来区分线程，线程也有自己的名称。想获取线程名称，我们就得获取线程的对象。
  示例1：获取线程名称

/*
线程都有自己默认的名称,格式为：Thread-编号，该编号从0开始。
*/
class Demo extends Thread
{
	private String name;
	Demo(String name)
	{
		this.name = name;
	}
	public void run()
	{
		for(int x=0 ; x<60 ; x++)
			//此处用this代表Demo类的对象调用Demo父类Thread的getName()方法来获取线程名称
			System.out.println(this.getName()+"运行"+x);
	}
}

public class ThreadDemo
{
	public static void main(String[] args) 
	{
		Demo d1 = new Demo("线程一");
		Demo d2 = new Demo("线程二");
		d1.start();
		d2.start();
				
		for(int x=0 ; x<60 ; x++)
			System.out.println("主线程运行"+x);	
	}
}

  示例2：设置取线程名称

/*
此处不用setName()方法设置线程名称，Thread类有一个Thread(String name)的构造方法,因此我们在初始化的时候就可以设置线程名称。
我们可以通过Thread类的有参构造方法，直接给线程名称赋值，而不需要通过setName()方法
也就得说，只要我们在子类中调用父类Thread的有参数的构造方法，我们就可以直接给线程对象赋值
thread类中有类似如下代码。
class Thread
{
	private String name;//这是存储线程名称的变量
	Thread(String name)
	{
		this.name = name;//通过Thread有参构造方法给线程名称赋值
	}
}
*/
class Demo extends Thread
{
	Demo(String name)
	{
		super(name);//调用父类Thread类有参的构造方法，并将想设置的名称用name参数传入
	}
	public void run()
	{
		//对于运行代码，每一个线程都有独立的一份，就是每一个线程都会有自己的内存放这些运行代码
		//如每一个线程都有自己的内存空间放自己的run()方法，局部的变量在每一个线程内存区域都有独立的一份
		for(int x=0 ; x<60 ; x++)
			System.out.println(Thread.currentThread().getName()+"运行"+x);
	//这里也可以是this.getName()，使用子类的引用（一个引用创建一个线程）调用父类的方法，this代表下面的d1、d2
	//currentThread()，该方法是静态方法，作用是：返回对当前正在执行的线程对象的引用，这里也是子类的引用（一个引用创建一个线程）调用父类的方法
	//this == Thread.currentThread()，但是Thread.currentThread()是通用的，而this不是通用的，这涉及到第二种线程创建方式
	}
}

public class ThreadDemo
{
	public static void main(String[] args) 
	{
		Demo d1 = new Demo("one---");
		Demo d2 = new Demo("two+++");
		d1.start();
		d2.start();
				
		for(int x=0 ; x<60 ; x++)
			System.out.println("主线程运行"+x);	
	}
}

  总结：

  1. Thread.currentThread():获取当前线程对象；
  2. getName(): 获取线程名称；
  3. 设置线程名称：setName或者构造函数。

2.2、实现Runnable接口创建线程类
  我们通过2个例子来说明这种创建方式，例子1：其他2类方法

/*
需求：简单的卖票程序，多个窗口同时买票。
*/

//创建一个卖票类，里面的卖票步骤要多线程执行，那么里面必须实现多线程的run()方法，将需要多线程执行的代码放到run()里面
package pack;
class Ticket extends Thread
{
	private static int ticket = 100;
	//用Ticket的构造方法设置线程对象的名称，如果我们不为线程设定名称，就会使用默认线程代号
	Ticket(String name)
	{
		super(name);
	}
	
	public void run()
	{
		while(true)
		{
			if(ticket > 0)
			{
				System.out.println(Thread.currentThread().getName()+"剩余票数为："+ticket--);
			}
		}
	}
}

public class ThreadDemo
{
	public static void main(String[] args) {
		Ticket t1 = new Ticket("窗口一");
//		Ticket t2 = new Ticket("窗口二");
//		Ticket t3 = new Ticket("窗口三");
//		Ticket t4 = new Ticket("窗口四");
		
		t1.start();
		t1.start();
		t1.start();
		t1.start();
	}
}
/*
结果我们发现每一个窗口都卖了100张票，而我们实际上只有100张票，这与实际是不符的。问题就在于，每创建一个对象里面就有100张票。
解决方案：让4个对象共享100张票 

方法1：将ticket设置为静态。
对于普通变量，是在对象加载的时候才会进入内存，因此当t1、t2、t3、t4分别调用start()方法，run()方法分别进入内存，
这时就会分别加载4个ticket进入内存，而且每一个ticke都是从100开始。如果我们设置ticket为静态，那么它在最开始Ticket类进入内存的时候，
就会赋值100加载进入内存，这个时候，不管后面多少个对象调用它，都只有一个静态的ticket。
（都是，由于静态成员的生命周期太长，我们不将ticket设置为静态）

方法2：只设置一个Ticket对象，一个对象多次启动线程，但是这种情况下会报错：无效的线程

Exception in thread "main"：java.lang.IllegalThreadStateException
	at java.lang.Thread.start(Thread.java:708)
	at pack.ThreadDemo.main(ThreadDemo.java:39)
线程已经从创建状态到运行状态，再次开启线程就没有意义。
 */

  例子2：实际使用方法

//创建一个卖票类，里面的卖票步骤要多线程执行，那么里面必须实现多线程的run()方法，将需要多线程执行的代码放到run()里面
package pack;
class Ticket implements Runnable
{
	private int ticket = 100;
	
	public void run()
	{
//不可以将ticket设置在run()方法之内，这样每一个线程进来调用run()方法都会重新有一个ticket，还是原来的4个线程的ticket都是从100开始
//而将ticket放在外面，我们只创建了一个Ticket对象，因此它只指向一个ticket成员，这样其他线程进来，都只有一个ticket；而前一种方法如果要有4个线程就要创建4个Ticket 对象，这样就会有4个ticket从100开始
//那么所有的线程都会使用一个ticket
//		int ticket = 100;
		while(true)
		{
			if(ticket > 0)
			{
				System.out.println(Thread.currentThread().getName()+"剩余票数为："+ticket--);
			}
		}
	}
}

public class ThreadDemo
{
	public static void main(String[] args) {
		//创建一个Ticket类的对象，这个对象不是线程，它与Thread类没有关系。只有Thread类及其子类对象可以创建线程
		Ticket t = new Ticket();
		
		//Thread有一个可以接受Runnable接口类型对象的构造方法：public Thread(Runnable target)
		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();
	}
}
/*
结果：4个线程同时在售100张票
 */

  方法2创建线程的步骤：

  1. 定义类实现Runnable接口；
  2. 覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中；
  3. 创建实现Runnable接口的子类对象；
  4. 通过Thread类建立线程对象，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数；
  5. 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

  为什么要将Runnable接口的子类对象传递给Thread的构造函数？
  因为，自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，就必须明确该run方法所属对象。

  关键：实现方式和继承方式有什么区别呢？实现方式好处：避免了单继承的局限性，因为如果我们继承了其他类，就无法继承Thread类实现多线程。（从视频11-8的13分钟开始处的解释）在定义线程时，建议使用实现方式。
  在本例子中还有一个好处，我们发现继承的方法，创建多个线程就有多个100张的票，每一个线程都有自己的run()方法；而在实现方法里面，我们创建Ticket的对象再将这个对象赋予每一个线程，这些线程实际上都是在共享同一个ticket，因为只创建一个Ticket对象，一个Ticket对象指向一个ticket，这样，就将“票”资源独立出来，分给多个线程共享。而继承方法没办法共享“票”资源！
  （Runnable接口的定义，其实就是在确立线程要运行代码所存放的位置，Thread类也实现Runnable接口）

  两种方式区别：
1）继承Thread:线程代码存放Thread子类run方法中；
2）实现Runnable，线程代码存在接口的子类的run方法。

3、多线程安全问题与同步代码块
3.1、线程安全问题
   注意视频11-9开始处分析的可能出现的错误。通过分析，我们发现多线程在运行的时候可能打印出0，-1，-2等错票，多线程的运行出现了安全问题。

/*
通过分析，我们发现多线程在运行的时候可能打印出0，-1，-2等错票
*/

package pack;
class Ticket implements Runnable
{
	private int ticket = 100;
	
	public void run()
	{
		while(true)
		{
			if(ticket > 0)
			{
		//我们使用Thread类的public static void sleep(long millis)throws InterruptedException方法来模拟视频中线程可能出现的错误
		//也就是使用sleep()方法让线程暂停一段时间，该方法如果被interrupt()方法中断，会抛出InterruptedException异常。
		//由于run()方法是重写接口的方法，它里面抛出的异常必须在run()里面处理，不能抛出。（注意接口的方法无法抛出异常）
				try
				{//调用thread的sleep方法，停10毫秒，模拟线程失去CPU执行权挂起
					Thread.sleep(5);
				}catch(Exception e)
				{
					//不处理
				}
				System.out.println(Thread.currentThread().getName()+"....sale:："+ticket--);
			}
		}
	}
}

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

   运行如上代码我们发现出现了视频中描述地错误——有负数的票在售卖！
在这里插入图片描述
   问题的原因： 在多线程中，当有多条语句在操作同一个线程共享数据（如此处的ticket）时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。
   解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，其他线程才可以执行。在一个线程的执行过程中，其他线程不可以参与执行。
   Java对于多线程的安全问题提供了专业的解决方式，就是同步代码块。格式如下：

synchronized(对象)
{
	需要被同步的代码
}
//这里的对象用什么类的对象都可以，我们一般使用Object类的对象

   对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。相应的代码如下：

class Ticket implements Runnable
{
	private int ticket = 100;
	Object obj = new Object();
	//run()方法里面的代码全部是线程运行代码，只有那些操作了多线程共享数据的代码需要被同步
	public void run()
	{
		while(true)
		{
			synchronized (obj)//同步
			{
				if(ticket > 0)
				{
					try
					{
						Thread.sleep(5);//调用thread的sleep方法，停10毫秒
					}catch(Exception e)
					{
						//不处理
					}
					System.out.println(Thread.currentThread().getName()+"....sale:："+ticket--);
				}
			}
		}
	}
}

public class ThreadDemo
{
	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();
	}
}
/*
 结果发现不再出现0，-1，-2的情况
 */

3.2、多线程同步代码块synchronized
3.2.1、synchronized运行原理
   对于上一节例子中的同步代码块——synchronized的运行原理解释：（具体参考视频11-10开始处解释）

while(true)
		{
			synchronized(obj)//obj就是“同步锁”，专业说法叫做监视器！
			{
				if(tick>0)
				{
					//try{Thread.sleep(10);}catch(Exception e){}
					System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
				}
			}
		}

   对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
   同步的前提：

  1. 必须要有两个或者两个以上的线程；
  2. 必须是多个线程使用同一个锁。（如果多个线程使用的是不同的代码，也必须要使用同一个锁。）

  必须保证同步中只能有一个线程在运行。且只有那些操作了多线程共享数据的代码需要被同步。

  好处：解决了多线程的安全问题；弊端：多个线程需要判断锁，较为消耗资源。

3.2.2、多线程同步函数与如何选择需要同步的代码
  我们如何选择需要同步的代码呢？我们看如下例子

/*
需求：银行有一个金库，有两个储户分别存300元，每次存100，存3次。注意金库总钱数sum是2个储户共同操作的

目的：该程序是否有安全问题，如果有，如何解决？

如何找问题：
1）明确哪些代码是多线程运行代码；（run()方法里面都是多线程运行代码）
2）明确共享数据；（这里b与sum都是共享数据！注意b也是！因为只有一个金库，那么只有一个金库对象！）
3）明确多线程运行代码中哪些语句是操作共享数据的（有多条代码操作共享数据的时候才需要进行同步）。

同步2种表现形式：同步代码块与同步函数。当二者封装的代码相同时，使用同步函数较方便！
*/

package pack;

//创建一个银行类
class Bank
{
	private int sum;//定义一个金库存储总钱数的变量sum，这个变量是2个储户共同操作的变量
//	Object obj = new Object();将同步关键字用来修饰函数，不需要对象！

	//我们注意到，同步代码块是用来封装代码，而函数也是用来封装代码。2者唯一的区别是同步代码块带有同步的特性，而函数没有，而他们封装的代码是一样的。
	//如果我们使得函数有了同步的特性，就不需要同步代码块了！
	public synchronized void add(int n)//将同步关键字用来修饰函数
	{
//		synchronized(obj)//添加同步后输出正常，可以打印每一次的添加过程
//		{
			sum = sum + n;//假设线程0在这里挂起，还没有打印，接下来线程1进来又将sum+100，此时线程0苏醒，执行打印
			//那么线程0打印出来的sum只有200而没有100这条添加的记录。接下来线程1苏醒，线程0挂起，又打印一次存储200的记录	
			try{Thread.sleep(10);}catch(Exception e) {};
			System.out.println(Thread.currentThread().getName()+"金库存钱总数sum="+sum);
//		}
	}
}

//创建一个储户类，该类要实现多储户存钱的动作，有多个线程，实现Runnable接口
class Customer implements Runnable
{
	private Bank b = new Bank();//创建一个私有的金库对象
	
	public void run()
	{
		//可以在for的地方就添加同步，但是这样的话只能一个人添加完全部的300后，另一个人才能添加。注意哪些代码要同步，哪些代码不应该同步！
		for(int x=0; x<3 ;x++)//x不需要同步，因为每一个线程有自己的x，它不是共享数据
		{
			b.add(100);//添加钱，只有一句代码操作共享数据，不需要同步
		}
	}
}

public class ThreadDemo
{
	public static void main(String[] args) 
	{
		Customer c = new Customer();
		
		Thread obj1 = new Thread(c);
		Thread obj2 = new Thread(c);
		
		obj1.start();
		obj2.start();
	}
}
/*
 错误结果：
Thread-1金库存钱总数sum=200
Thread-0金库存钱总数sum=200
Thread-0金库存钱总数sum=400
Thread-1金库存钱总数sum=400
Thread-0金库存钱总数sum=600
Thread-1金库存钱总数sum=600
*/

3.2.3、同步函数锁的原理
  我们再看3.2.1中卖票的例子。

/*
 同步函数用的是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象引用，就是this，所以同步函数使用的锁是this。（注意同步的锁是对象）如果要同步的代码块有循环就不要用同步函数。
 */

package pack;
class Ticket implements Runnable
{
	private int ticket = 100;
//	Object obj = new Object();
	
	public void run()
	{//不可以直接将synchronized放在run()方法处，因为一当某一个线程进去，里面是while(true)的无线循环，
	//这样这个线程一直不会结束，那么其他线程一直进不来，导致只有一个线程在卖票，而且这个线程卖完票，也不会结束。
		while(true)
		{
//			synchronized (obj){}
			this.show();//此处的this相当于Ticket类的对象
		}
	}
	
	//我们可以将需要同步的代码单独封装为一个方法，并使得这个方法同步即可
	public synchronized void show()
	{
		if(ticket > 0)
		{
			try{Thread.sleep(5);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+"....sale:："+ticket--);
		}	
	}	
}

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

  我们通过下面的例子进行验证：

/*
 同步函数用的是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象引用，就是this，所以同步函数使用的锁是this。（注意同步的锁是对象）

我们通过如下程序来验证：使用两个线程来卖票，一个线程在同步代码块中，一个线程在同步函数中，都在执行卖票动作。
如果2个线程是同步的，那么他们就不会出现错误的票。
 */

package pack;
class Ticket implements Runnable
{
	private int ticket = 100;
	Object obj = new Object();
	boolean flag = true;//设置一个布尔型的变量来控制2个线程的切换
	
	public void run()
	{
		if(flag)//一个线程设置为真，运行同步代码块
		{
			while(true)
			{
				synchronized(this)
				{
					if(ticket > 0)
					{
						try{Thread.sleep(5);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName()+"....同步代码块:："+ticket--);
					}	
				}
			}
		}
		else//一个线程设置为假，运行同步函数
		{
			while(true)
			{
				show();
			}
		}
	}
	
	public synchronized void show()
	{
		if(ticket > 0)
		{
			try{Thread.sleep(5);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+"....同步函数:："+ticket--);
		}	
	}	
}

public class ThreadDemo
{
	public static void main(String[] args) {
		Ticket t = new Ticket();
		
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();//线程1进去为真，运行同步代码块。但是运行到这里这个线程不一定立即执行，可能CPU在主线程那边，所以这一句可能不会立即执行！
		try{Thread.sleep(10);}catch(Exception e){}//使得主线程停一下，在这段时间内如果t1获得CPU的执行权，就会执行同步代码块
		t.flag = false;//一个线程运行结束，将flag设置为false，另一个线程进去运行同步函数
		t2.start();
		System.out.println("over");
	}
}
/*
结果1：
发现，线程0和线程1都在同步函数里面执行，而不在同步代码块里面执行。
一共有3个线程，因为主线程可能执行太快了，将
t1.start();
t.flag = false;
t2.start();
3句代码全部执行完，再执行其他2个线程，这个时候flag为false，那么只在同步函数里面执行！
因此我们必须加一个sleep来延时，防止主线程执行太快！
*/

/*
结果2：
Thread-0....同步代码块:：2
Thread-1....同步函数:：1
Thread-0....同步代码块:：0

发现出现序号为0的票，这样操作不安全！
为什么？同步2个前提：多个线程，线程使用同一个锁。
因此我们将同步代码块的锁改为this。发现错误消失了！这说明同步函数的锁是this!

对于：也就是将flag置为false之后，运行线程1同步函数之后，还会再运行flag=true时的同步代码块。而且线程0只对应同步代码块，线程1只对应同步函数。这是因为我们设置sleep之后，线程0会获得CPU执行权进去，这个时候flag=true，它会执行同步代码块，而下次线程0再获得CPU执行权，这个时候它还是会从flag=true时的状态进入run()方法，还是执行同步代码块。如果主函数不sleep，那么线程0第一次开启flag=false，下次再进来还是会从flag=false的状态进入run()。总结：线程再次获取CPU执行权运行多线程代码的时候，还是会回到它第一次进入多线程代码时的状态——如这里线程0再次运行会回到flag=false之前进行多线程代码。
Thread-1....同步函数:：20
Thread-1....同步函数:：19
Thread-0....同步代码块:：18
Thread-0....同步代码块:：17
*/

3.2.4、静态同步函数的锁
  我们通过下面的例子来说明静态同步函数的锁

/*
 如果同步函数被静态修饰后，使用的锁是什么呢？
 通过验证，发现不在是this，因为静态方法中也不可以定义this！
 
 静态进内存，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class  该对象的类型是Class
 字节码文件对象既Class 类名.class = new Class();
 “.class”是字节码文件，类名.class就是类的字节码文件对象
 静态的同步方法，使用的锁是该方法所在类的字节码文件对象:类名.class，并且由于字节码文件唯一，那么该字节码文件对象在内存里面是唯一的。
 
 */

package pack;
class Ticket implements Runnable
{
	private static int ticket = 100;//同步函数使用的成员变量也设置为静态
	Object obj = new Object();
	boolean flag = true;//设置一个布尔型的变量来控制2个线程的切换
	
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(Ticket.class)
				{
					if(ticket > 0)
					{
						try{Thread.sleep(5);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName()+"....同步代码块:："+ticket--);
					}	
				}
			}
		}
		else
		{
			while(true)
			{
				show();
			}
		}
	}
	
	public static synchronized void show()//将同步函数设置为静态
	{
		if(ticket > 0)
		{
			try{Thread.sleep(5);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+"....同步函数:："+ticket--);
		}	
	}	
}

public class ThreadDemo
{
	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();
	}
}
/*
结果1：
......
Thread-1....同步函数:：2
Thread-0....同步代码块:：1
Thread-1....同步函数:：0

我们发现出现为0的票，错误！说明静态代码块与静态方法用的不是同一个锁，说明静态方法用的锁不是this
将静态代码块的对象改为Ticket.class之后，没有0的票，说明静态代码块与静态方法使用的对象相同，都是ticket.class
*/

3.3、多线程的单例设计模式
  下面例子中我们讨论一下多线程模式下的单例设计模式：

package pack;
/*
 饿汉式（一般写饿汉式没问题，所以写饿汉式！）
class Single
{
	//私有化构造方法
	private Single() {}
	//创建一个私有的对象
	private static final Single s = new Single();
	//设计一个方法将私有的对象提供出去
	public static Single getInstance()
	{
		return s;
	}
}
*/

//懒汉式
class Single
{
	
	private Single() {}
	private static Single s = null;
	
	//s是共享数据，可能有多个线程并发访问getInstance()方法。
	//我们可以在函数处设置同步函数，但是如果线程很多，每一个线程想获取对象，都必须判断函数的锁，这样程序比较低效
	public static Single getInstance()
	{
		//我们使用同步代码块来做，但是这样仍然是每一个对象进来都要判断锁，那么我们再加一个判断条件
		//这样一个线程进来，将s设置为对象，以后进来判断s不为空而是new Single()，就不需要再判断锁，直接返回！（视频11-14，6.32秒处开始的解释）
		//这样的话就不需要每一个线程都来判断锁（同步函数每一个线程都要判断锁），只有前面2个线程需要判断（视频解释），而且多个线程只能创建一个对象！
		//这种叫做用双重判断的方式解决问题！减少判断锁的次数，提高了懒汉式的效率。
		if(s == null)
		{
			synchronized(Single.class)//我们使用Single类的字节码文件对象作为synchronized的对象锁
			{
			//这里有多条语句在操作共享数据s，一条在判断，一条在赋值
				if(s == null)
					//-->A：线程A挂在这里 -->B：线程B挂在这里
					//当线程A苏醒，创建一个对象，线程B苏醒，又创建一个对象。本来就应该只有一个对象！
					//因此我们将操作共享数据的代码同步起来
					s = new Single();
			}
		}
		return s;
	}
}

/*
 面试：懒汉式与饿汉式有什么不同？
懒汉式的特点在于延迟实例加载，但是在多线程访问时，懒汉式容易出现安全问题。可以加同步来解决这个问题，同步代码块与同步函数都可以，
但是同步函数有些低效，而同步代码块也是，用双重判断的形式可以解决同步代码块的低效问题。使用的锁是Single类所属的字节码文件对象：Single.class
*/

3.4、多线程死锁
1）死锁产生原因？（见视频11-15解释）
  Java中死锁最简单的情况是，一个线程T1持有锁L1并且申请获得锁L2，而另一个线程T2持有锁L2并且申请获得锁L1，因为默认的锁申请操作都是阻塞的，所以线程T1和T2永远被阻塞了。导致了死锁。这是最容易理解也是最简单的死锁的形式。但是实际环境中的死锁往往比这个复杂的多。可能会有多个线程形成了一个死锁的环路，比如：线程T1持有锁L1并且申请获得锁L2，而线程T2持有锁L2并且申请获得锁L3，而线程T3持有锁L3并且申请获得锁L1，这样导致了一个锁依赖的环路：T1依赖T2的锁L2，T2依赖T3的锁L3，而T3依赖T1的锁L1。从而导致了死锁。
  从这两个例子，我们可以得出结论，产生死锁可能性的最根本原因是：线程在获得一个锁L1的情况下再去申请另外一个锁L2，也就是锁L1想要包含了锁L2，也就是说在获得了锁L1，并且没有释放锁L1的情况下，又去申请获得锁L2，这个是产生死锁的最根本原因。简单地讲，就是同步中嵌套同步，而锁却不同。另一个原因是默认的锁申请操作是阻塞的。
例子1：

/*

 */
package pack;
class Ticket implements Runnable
{
	private static int ticket = 100;
	Object obj = new Object();
	boolean flag = true;
	
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(obj)//同步代码块
				{
					//0线程进来，持有obj锁，想要进show，需要this锁
					show();//同步代码块中包含同步函数	
				}
			}
		}
		else
			while(true)
				show();
	}
	
	public synchronized void show()//同步函数
	{
		//1线程进来，持有this锁，想要进同步代码块，需要obj锁
		synchronized(obj)//同步函数中包含同步代码块
		{
			if(ticket > 0)
			{
				try{Thread.sleep(5);}catch(Exception e){}
				System.out.println(Thread.currentThread().getName()+"....同步函数:："+ticket--);
			}	
		}
	}	
}

public class ThreadDemo
{
	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();
	}
}
/*
 运行发现票没有卖完程序就不动了，也就是程序锁上了！（看视频11-15，6分10秒开始处的解释）
*/

例子2：死锁

/*
掌握词程序，面试可能用到！
 */
package pack;

//创建一个MyLock类，用于提供2个Object的对象锁，为了方便这两个对象被调用，设定其为static类型
class MyLock
{
	static Object locka = new Object();
	static Object lockb = new Object();
}

//创建一个Test类实现Runnable接口
class Test implements Runnable
{
	private boolean flag;//设置一个布尔型的变量Flag
	Test(boolean flag)
	{
		this.flag = flag;//提供构造函数为flag赋值
	}
	
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(MyLock.locka)//当flag=true，进入的同步代码块locka在外
				{
					System.out.println(Thread.currentThread().getName()+"...if locka ");
					synchronized(MyLock.lockb)//锁lockb在内
					{
						System.out.println(Thread.currentThread().getName()+"...if lockb ");
					}
				}
			}
		}
		else
		{
			while(true)
			{
				synchronized(MyLock.lockb)//当flag=true，进入的同步代码块lockb在外
				{
					System.out.println(Thread.currentThread().getName()+"..else lockb ");
					synchronized(MyLock.locka)//锁locka在内
					{
						System.out.println(Thread.currentThread().getName()+"..else lockba ");
					}
				}
			}
		}
	}
}

public class ThreadDemo
{
	public static void main(String[] args) {
		Thread t1 = new Thread(new Test(true));//线程0进去的时候进入if部分
		Thread t2 = new Thread(new Test(false));//线程1进去的时候进入else部分
		t1.start();
		t2.start();
	}
}
/*
结果：
Thread-0...if locka 
Thread-1..else lockb 
线程0拿着locka，想要进入下一层的同步代码块，但是没有lockb，因为此时线程1拿着lockb，没有locka，两个线程形成了死锁！
*/

参考阅读文章：
多线程详解
多线程详解

4、就业班多线程补充
补充1：
  并发：指两个或多个事件在同一个时间段内发生。
  并行：指两个或多个事件在同一时刻发生（同时发生）。
在这里插入图片描述

补充2：
  进程与线程
进程
线程
补充3：
  线程的调度：
1）分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
2）抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的为抢占式调度。

补充4：
  主线程的内存原理
在这里插入图片描述
  多线程的内存图解
在这里插入图片描述
补充5：Thread和Runnable的区别
  相应的代码如下

实现Runnable接口创建多线程程序的好处:
     1.避免了单继承的局限性
         一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
         实现了Runnable接口,还可以继承其他的类,实现其他的接口
     2.增强了程序的扩展性,降低了程序的耦合性(解耦)
         实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
         实现类中,重写了run方法:用来设置线程任务
         创建Thread类对象,调用start方法:用来开启新线程

补充6：匿名内部类实现多线程
  代码如下

package com.itheima.demo05.InnerClassThread;
/*
    匿名内部类方式实现线程的创建

    匿名:没有名字
    内部类:写在其他类内部的类

    匿名内部类作用:简化代码
        把子类继承父类,重写父类的方法,创建子类对象合一步完成
        把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成
    匿名内部类的最终产物:子类/实现类对象,而这个类没有名字

    格式:
        new 父类/接口(){
            重复父类/接口中的方法
        };
 */
public class Demo01InnerClassThread {
    public static void main(String[] args) {
        //线程的父类是Thread
        // new MyThread().start();
        new Thread(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"黑马");
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl();//多态
        Runnable r = new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"程序员");
                }
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"传智播客");
                }
            }
        }).start();
    }
}

补充7：线程的几类状态
  如下图
在这里插入图片描述
在这里插入图片描述

黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
进程和线程
.: Easy Style - 将PHP进行到底 :.
06-17 2487
进程：多任务系统的产物 很久很久以前，是没有进程这个东西的。那时候的操作系统只能把要做的工作排好队，做完这件再做下一件，最多也就加个优先级，哪个关系好就先做哪一个。于是那些想一边听歌一边写程序的程序员们便不干了，开始修理那个操作系统，使之能同时运行多个程序。于是进程就出现了：它就是一个程序在数据集合上的一次执行。 因为突然变得僧多粥少了，所以每个进程只好做一些额外的事情：在别人
黑马程序员 进程与线程
u012588267的专栏
11-17 619
---------------------- ASP.Net+Android+IOS">http://edu.youkuaiyun.com"target="blank">ASP.Net+Android+IOS开发、.Net">http://edu.youkuaiyun.com"target="blank">.Net培训、期待与您交流！ ---------------------- 一：进程和线程介绍：
黑马程序员——07 进程与线程
wentaonpa的专栏
07-04 469
------- Windows Phone 7手机开发、.Net培训、期待与您交流！ ------- ——进程 可以理解为现在正在运行的程序 进程与线程的关系：进程包含线程 设一个进程要完成两个任务 任务1：a1-b1-c1 任务2：a2-b2-c2 同步执行的过程：a1-b1-c1-a2-b2-c2  异步执行的过程：a1-b1-c1
毕向东讲解（摘）—1.多线程概述
五彩世界的博客
10-12 295
进程：是一个正在执行中的程序。 每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元。 线程就是在控制着进程的执行。   一个进程中至少有一个线程。     Java VM 启动的时候会有一个进程  java.exe   该进程中至少有一个线程负责java程序的执行。 而且这个线程运行的代码存在于main方法中。
毕向东Java视频学习笔记【Day11-Day13 多线程】
ACMer_Shadow的博客
07-03 4584
Java_Day12 多线程01 进程：正在进行中的程序(直译). 线程：就是进程中一个负责程序执行的控制单元(执行路径) 一个进程中可以多执行路径，称之为多线程。 一个进程中至少要有一个线程。 开启多个线程是为了同时运行多部分代码。 每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。 多线程好处：解决了多部分同时运行的问题。 多线程的弊端：线程太多回到效
Java多线程与并发库视频资源网盘链接
04-11
Java多线程与并发库是Java开发者必备的重要技能之一，尤其对于处理高并发场景的应用开发至关重要。本视频资源集合旨在帮助初级开发人员深入理解和掌握这一关键领域，通过学习，你可以提升自己的程序性能优化能力，更...
黑马程序员_张孝祥_Java多线程与并发库
05-17
黑马程序员_张孝祥_Java多线程与并发库,老师讲的非常仔细,老师很有耐心.欢迎大家下载学习.
黑马程序员_张孝祥_Java多线程与并发库 视频+代码+资料
10-29
根据给定文件的信息，我们可以提炼出以下关于Java多线程与并发库的相关知识点： ### Java多线程基础 1. **线程的概念**：在Java中，线程是程序执行流的基本单元。一个标准的Java应用程序至少有一个线程，即主...
《Java基础入门（第3版）》【黑马程序员著】：课后习题答案与解析（完整版）
最新发布
03-24
Java基础教育-涵盖面向对象、API应用、异常处理等核心技术课后习题详解
黑马程序员_毕向东_Java基础源码.rar
11-29
毕向东的基础代码 黑马程序员 初学者必备
黑马毕向东Java基础全集
11-26
毕向东，黑马大牛，java基础讲的很透彻，举一反三，讲课风格幽默
java各知识点详细总结(毕向东笔记整理)
03-01
第一章：编程基础 3-11 第二章：数组 11 -31 第三章：面向对象程序开发 31 -74 第四章：异常机制 74 -89 第五章：多线程技术 89 -122122122 第六章：常用类 API 122API 122 API 122API 122API 122API 122API 122-139139139 第七章：集合框架（容器） +其他类对象使用 139 -199 第八章：IO 流 199 -280 第九章：GUIGUIGUI编程 280 -284 第十章：网络编程 284 -309309309 第十一章：反射机制 310 -315315315 第十二章：正则表达式 315 -322322322 第十三章：HTMLHTMLHTMLHTML语言 322 -335 335 335 335 335 335 335 335 335 第十四章：CSS CSS语言 335335335-341 341 341 341 341 341 341 第十五章：JavaScrJavaScr JavaScr iptipt 语言 341341341-375 第十六章：DOM 375
黑马毕向东java基础视频
05-19
黑马毕向东java基础视频黑马毕向东java基础视频黑马毕向东java基础视频黑马毕向东java基础视频黑马毕向东java基础视频
多线程2--毕向东基础视频教程学习笔记
weixin_30776273的博客
01-20 118
Day12多线程： 1.线程间通信-示例代码 2.线程间通信-解决安全问题 3.线程间通信-等待唤醒机制 4.线程间通信-代码优化 5.线程间通信-生产者消费者 1.线程间通信-示例代码 线程间通信： 其实就是多个线程在操作同一个资源， 但操作的动作不同。 示例代码： 1 class Res 2 2 { 3 3 String name...
毕向东笔记摘抄之多线程
dada_6666的博客
11-16 463
进程：是一个正在执行的程序。 每一个进程都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。线程：就是进程中的一个独立的控制单元。 线程在控制着进程的进行。一个进程中至少有一个线程。Java VM 启动的时候有一个进程java.exe该进程中至少一个线程负责java程序的执行。 而且这个线程运行的代码存在于main方法中。 该线程称之为主线程。
黑马毕向东Java课程笔记（day15-6——15-13）:集合类（集合框架）——泛型+集合对象排序与比较+JDK9对集合的优化+Debug
LKJgdut的博客
09-07 242
1、泛型概述级示例   泛型的特点如下 泛型：JDK1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制。用于限定类型，避免出现ClassCastException类型转换异常！ 好处 1.将运行时期出现问题ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时问题减少，安全。 2，避免了强制转换麻烦。   泛型示例1 /* 练习：按照字符串长度...
黑马程序员_毕向东_Java基础_DAY02学习笔记
longlangss的专栏
06-28 1542
------- android培训、java培训、期待与您交流！ ---------- /* 黑马程序员_毕向东_Java基础视频教程—— 0201-标识符.avi 0202-常量.avi 0203-进制的特点.avi 0204-进制转换(十进制和二进制).avi 0205-进制转换(八进制和十六进制).avi 0206-进制转换(负数二进制).avi 0207-变量.a
多线程--毕向东java基础教程视频学习笔记
weixin_30652271的博客
11-29 115
目录 1.多线程运行的安全问题 2.多线程同步代码块 3.同步方法的锁是this 4.静态同步方法的锁是Class对象 5.单例设计模式（面试中的考点） 6.死锁（一个发生死锁的例子） 多线程运行的安全问题 例子：售票系统 1 class Ticket implements Runnable 2 { 3 //定义静态变量ticket 4 p...
Java多线程与并发库学习资源分享
标题《Java多线程与并发库视频资源网盘链接》以及描述中提到的内容指向一个关于Java编程语言中多线程和并发处理技术的教学资源。本知识点旨在详细介绍Java中的多线程与并发编程，并提供学习这些概念所需的资源。考虑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值