多线程基础笔记

多线程的引入（了解）

什么是线程

• 线程是程序执行的一条路径，一个进程中可以包含多条线程
• 多线程并发执行可以提高程序的效率，可以同时完成多项工作

多线程的应用场景

• 红蜘蛛同时共享屏幕给多个电脑
• 迅雷开启多条线程一起下载
• QQ同时和多个人一起视频
• 服务器同时处理多个客户端请求

多线程并行和并发的区别（了解）

并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)

并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。

比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。

如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。

java程序运行原理和JVM的启动是多线程的吗？（了解）

java程序运行原理

java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程，该进程会自动启动一个"主线程"，然后主线程去调用某个类的main方法。

JVM的启动是多线程的吗

JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

多线程实现方式一（掌握）

继承Thread类

• 自定义类继承Thread
• 重写run方法
• 把新线程要做的事写在run方法中
• 开启新线程，内部会自动执行run方法

package com.heima.thread;

public class Demo1_Thread {
    
    

	public static void main(String[] args) {
    
    

		MyThread mt = new MyThread();								// 4、创建Thread类的子类对象
		mt.start();                                                 // 5、开启线程

		for (int i = 0; i < 1000; i++) {
    
    
			System.out.println("bb");
		}
	}
}

class MyThread extends Thread {
    
     									// 1、继承Thread类
	public void run() {
    
     											// 2、重写run方法
		for (int i = 0; i < 1000; i++) {
    
    							// 3、将要执行的代码写在run方法中
			System.out.println("aaaaaaaaaaaaa");
		}
	}
}

多线程实现方式二（掌握）

实现Runnable接口

• 定义类实现Runnable接口
• 实现run方法
• 把新线程要做的事写在run方法中
• 创建自定义的Runnable的子类对象
• 创建Thread对象，传入Runnable
• 调用start方法开启线程，内部会自动调用Runnable的run方法

package com.heima.thread;

public class Demo2_Runnable {
    
    

	public static void main(String[] args) {
    
    
		MyRunnable mr = new MyRunnable(); 						// 4,创建Runnable的子类对象
		Thread t1 = new Thread(mr);								// 5,将其当作参数传递给Thread的构造函数
	    t1.start();												// 6,开启线程
		for (int i = 0; i < 1000; i++) {
    
    
			System.out.println("bb");
		}
	}
}

class MyRunnable implements Runnable {
    
     							// 1,定义一个类实现Runnable
	@Override
	public void run() {
    
     										// 2,重写run方法
		for (int i = 0; i < 1000; i++) {
    
    
			System.out.println("aaaaaaaaaaaaa"); 				// 3,将要执行的代码写在run方法中
		}
	}
}

实现Runnable的原理（了解）

查看源码

• 看Thread类的构造函数，传递了Runnable接口的引用
• 通过init（）方法找到传递的target给成员变量的target赋值
• 查看run方法，发现run方法中有判断，如果target不为null，就会调用Runnable接口子类对象的run（）方法

两种方式的区别（掌握）

查看源码的区别

• 继承Thread：由于子类重写了Thread类的run（）方法，当调用start（）方法时，直接找子类的run（）方法。
• 实现Runnable：构造函数中传入了Runnable的引用，成员变量记住了它，start（）方法调用run（）方法时内部判断成员变量Runnable的引用是否为空，不为空编译时看的是Runnable的run（）方法，运行时执行的是子类的run（）方法。

继承Thread

• 好处：可以直接使用Thread类中的方法，代码简单
• 弊端：如果已经有了父类，就不能用这种方法

实现Runnable接口

• 好处：即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
• 弊端：不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

匿名内部类实现线程的两种方式（掌握）

• 继承Thread类
• 实现Runnable接口

package com.heima.thread;

public class Demo3_Thread {
    
    
	public static void main(String[] args) {
    
    
		new Thread() {
    
     											// 1、继承Thread类
			public void run() {
    
    									// 2、重写run()方法
				for (int i = 0; i < 1000; i++) {
    
    				// 3、将要执行的代码写在run()方法中
					System.out.println("aaaaaaaaaaaaa");
				}
			}
		}.start();												// 4、开启线程
		
		new Thread(new Runnable() {
    
    								// 1、将Runnable的子类对象传递给Thread的构造方法
			public void run() {
    
    									// 2、重写run()方法
				for (int i = 0; i < 1000; i++) {
    
    				// 3、将要执行的代码写在run()方法中
					System.out.println("bb");
				}
			}
		}).start();												// 4、开启线程
	}
}

获取名字和设置名字（掌握）

• 获取名字：通过getName()方法获取线程对象的名字
• 设置名字：通过构造函数可以传入String类型的名字
• 通过setName(String)方法可以设置线程对象的名字

package com.heima.threadmethod;
public class Demo1_Thread {
    
    
	public static void main(String[] args) {
    
    
		demo1();
		Thread t1 = new Thread() {
    
    
			@Override
			public void run() {
    
    
				System.out.println(this.getName() + "....aaaaaa");
			}
		};

		Thread t2 = new Thread() {
    
    
			@Override
			public void run() {
    
    
				System.out.println(this.getName() + "....bb");
			}
		};

		t1.setName("张三");
		t2.setName("李四");
		t1.start();
		t2.start();
	}

	private static void demo1() {
    
    
		new Thread("芙蓉姐姐") {
    
     											// 通过构造方法给name赋值
			@Override
			public void run() {
    
    
				System.out.println(this.getName() + "...aaaaaaaaaa");
			}
		}.start();

		new Thread("凤姐") {
    
     												// 通过构造方法给name赋值
			@Override
			public void run() {
    
    
				System.out.println(this.getName() + "...bb");
			}
		}.start();
	}
}

获取当前线程的对象（掌握）

Thread.currentThread(), 主线程也可以获取

package com.heima.threadmethod;

public class Demo2_Thread {
    
    

	public static void main(String[] args) {
    
    
		new Thread() {
    
    
			public void run() {
    
    
				System.out.println(getName() + "....aaaaaaaa");
			}
		}.start();

		new Thread(new Runnable() {
    
    

			@Override
			public void run() {
    
    
				// Thread.currentThread()获取当前正在执行的线程
				System.out.println(Thread.currentThread().getName() + "...bb");
			}
		}).start();
		Thread.currentThread().setName("我是主线程");
		System.out.println(Thread.currentThread().getName());
	}
}

休眠线程（掌握）

Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000

package com.heima.threadmethod;

public class Demo3_Thread {
    
    
	public static void main(String[] args) throws InterruptedException {
    
    

		// demo1();
		new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 10; i++) {
    
    
					try {
    
    
						Thread.sleep(1000);
					} catch (InterruptedException e) {
    
    

						e.printStackTrace();
					}
					System.out.println(getName() + "...aaaaaaaaaa");
				}
			}
		}.start();

		new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 10; i++) {
    
    
					try {
    
    
						Thread.sleep(1000);
					} catch (InterruptedException e) {
    
    

						e.printStackTrace();
					}
					System.out.println(getName() + "...bb");
				}
			}
		}.start();
	}

	private static void demo1() throws InterruptedException {
    
    
		for (int i = 20; i >= 0; i--) {
    
    
			Thread.sleep(1000);
			System.out.println("倒计时第" + i + "秒");
		}
	}
}

守护线程（掌握）

setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出

package com.heima.threadmethod;

public class Demo4_Thread {
    
    
	public static void main(String[] args) {
    
    

		Thread t1 = new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 2; i++) {
    
    
					System.out.println(getName() + "...aaaaaaaa");
				}
			}
		};

		Thread t2 = new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 10; i++) {
    
    
					System.out.println(getName() + "...bb");
				}
			}
		};

		t2.setDaemon(true); 									// 设置为守护线程
		t1.start();
		t2.start();
	}
}

加入线程（了解）

• join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
• join(int), 可以等待指定的毫秒之后继续

package com.heima.threadmethod;

public class Demo5_Join {
    
    
	/*
	 * join()当前线程暂停，等待指定的线程执行结束后，当前线程再继续
	 */
	public static void main(String[] args) {
    
    

		final Thread t1 = new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 10; i++) {
    
    
					System.out.println(getName() + "...aaaaaaaaa");
				}
			}
		};

		Thread t2 = new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 10; i++) {
    
    
					if (i == 2) {
    
    
						try {
    
    
							t1.join(); 								// 插队指定的时间,过了指定时间后,两条线程交替执行
						} catch (InterruptedException e) {
    
    
							e.printStackTrace();
						}
					}
					System.out.println(getName() + "...bb");

				}
			}
		};

		t1.start();
		t2.start();

	}
}

礼让线程（了解）

• yield让出cpu

package com.heima.threadmethod;
public class Demo6_Yield {
    
    
	public static void main(String[] args) {
    
    
		new MyThread().start();
		new MyThread().start();
	}

}

class MyThread extends Thread {
    
    
	public void run() {
    
    
		for (int i = 1; i <= 1000; i++) {
    
    
			if (i % 10 == 0) {
    
    
				Thread.yield();                          // 让出CPU
			}
			System.out.println(getName() + "..." + i);
		}
	}
}

设置线程的优先级（了解）

• setPriority()设置线程的优先级

package com.heima.threadmethod;

public class Demo7_Priority {
    
    

	public static void main(String[] args) {
    
    
		Thread t1 = new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 1000; i++) {
    
    
					System.out.println(getName() + "...aaaaaaa");
				}
			}
		};

		Thread t2 = new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 1000; i++) {
    
    
					System.out.println(getName() + "...bb");
				}
			}
		};

		// t1.setPriority(1);
		// t2.setPriority(10); 										//设置最大优先级
		t1.setPriority(Thread.MAX_PRIORITY); 						// 设置最大的线程优先级
		t2.setPriority(Thread.MIN_PRIORITY);						// 设置最小的线程优先级
		t1.start();
		t2.start();
	}
}

同步代码块（掌握）

什么情况下需要同步

• 当多线程并发，有多段代码同时执行时，我们希望一段代码执行的过程中CPU不要切换到其他线程工作，这时就需要同步
• 如果两段代码是同步的，那么同一时间只能执行一段，在一段代码执行结束之前，不会执行另一段代码。

同步代码块

• 使用关键字synchronized关键字加上一个锁对象来定义一段代码，这就叫同步代码块
• 多个同步代码块如果使用相同的锁对象，那么他们就是同步的

package com.heima.sync;

public class Demo1_Synchronized {
    
    

	/*
	 * 同步代码块
	 */
	public static void main(String[] args) {
    
    
		final Printer p = new Printer();
		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					p.print1();
				}
			}
		}.start();
		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					p.print2();
				}
			}
		}.start();
	}
}

class Printer {
    
    
	Demo d = new Demo();
	public void print1() {
    
    
		synchronized (d) {
    
                      // 同步代码块,锁机制,锁对象可以是任意的
			System.out.print("黑");
			System.out.print("马");
			System.out.print("程");
			System.out.print("序");
			System.out.print("员");
			System.out.print("\r\n");
		}
	}

	public void print2() {
    
    
		// synchronized(new Demo()) {        //锁对象不能用匿名对象,因为匿名对象不是同一个对象
		synchronized (d) {
    
    
			System.out.print("传");
			System.out.print("智");
			System.out.print("播");
			System.out.print("客");
			System.out.print("\r\n");
		}
	}
}

class Demo {
    
    
}

同步方法（掌握）

• 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
• 非静态同步函数的锁是:this
• 静态的同步函数的锁是:字节码对象

package com.heima.sync;

public class Demo2_Synchronized {
    
    

	/*
	 * 同步代码块
	 */
	public static void main(String[] args) {
    
    
		final Printer2 p = new Printer2();
		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					p.print1();
				}
			}
		}.start();
		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					p.print2();
				}
			}
		}.start();
	}
}

class Printer2 {
    
    
	// 非静态的同步方法的锁对象是什么？
	// 答：非静态的同步方法的锁对象是this
	// 静态同步方法的锁对象是什么？
	// 答：静态同步方法的锁对象是该类的字节码对象
	public static synchronized void print1() {
    
                      // 同步方法只需要在方法上加synchronized关键字即可
		// synchronized (this) {                                // 非静态的同步方法的锁对象是this
		System.out.print("黑");
		System.out.print("马");
		System.out.print("程");
		System.out.print("序");
		System.out.print("员");
		System.out.print("\r\n");
	}

	public void print2() {
    
    
		// synchronized(new Demo()) {                           //锁对象不能用匿名对象,因为匿名对象不是同一个对象
		// synchronized (this) {                                // 非静态的同步方法的锁对象是this
		synchronized (Printer2.class) {
    
    
			System.out.print("传");
			System.out.print("智");
			System.out.print("播");
			System.out.print("客");
			System.out.print("\r\n");
		}
	}
}

线程安全问题（掌握）

• 多线程并发操作同一数据时, 就有可能出现线程安全问题
• 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作

package com.heima.sync;

public class Tickets {
    
    
	/*
	 * 需求:铁路售票,一共100张,通过四个窗口卖完.
	 */
	public static void main(String[] args) {
    
    

		new Ticket().start();
		new Ticket().start();
		new Ticket().start();
		new Ticket().start();

	}
}

class Ticket extends Thread {
    
    

	private static int ticket = 100;

	// private static Object obj = new Object(); //如果用引用数据类型成员变量当作锁对象,必须是静态的
	public void run() {
    
    
		while (true) {
    
    
			synchronized (Ticket.class) {
    
    

				if (ticket <= 0) {
    
    
					break;
				}
				try {
    
    
					Thread.sleep(10);
				} catch (InterruptedException e) {
    
    
					e.printStackTrace();
				}
				System.out.println(getName() + "这是第" + ticket-- + "号票");
			}
		}
	}
}

火车站卖票的例子用实现Runnable接口（掌握）

package com.heima.sync;

public class Demo4_Tickets {
    
    
	/*
	 * 火车站卖票的例子用实现Runnable接口
	 */
	public static void main(String[] args) {
    
    

		MyTicket mt = new MyTicket();

		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();
		new Thread(mt).start();

	}
}

class MyTicket implements Runnable {
    
    

	private int ticket = 100;

	public void run() {
    
    
		while (true) {
    
    
			synchronized (this) {
    
    
				if (ticket <= 0) {
    
    
					break;
				}
				try {
    
    
					Thread.sleep(10);
				} catch (InterruptedException e) {
    
    
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "这是第" + ticket-- + "号票");
			}
		}
	}
}

死锁（了解）

• 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
• 尽量不要嵌套使用

package com.heima.sync;

public class DeadLock {
    
    

	/**
	 * @param args
	 */
	private static String s1 = "筷子左";
	private static String s2 = "筷子右";

	public static void main(String[] args) {
    
    
		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					synchronized (s1) {
    
    
						System.out.println(getName() + "...获取" + s1 + "等待" + s2);
						synchronized (s2) {
    
    
							System.out.println(getName() + "...拿到" + s2 + "开吃");
						}
					}
				}
			}
		}.start();

		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					synchronized (s2) {
    
    
						System.out.println(getName() + "...获取" + s2 + "等待" + s1);
						synchronized (s1) {
    
    
							System.out.println(getName() + "...拿到" + s1 + "开吃");
						}
					}
				}
			}
		}.start();
	}
}

以前的线程安全的类回顾（掌握）

• 回顾以前说过的线程安全问题
• 看源码：Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
• Vector是线程安全的,ArrayList是线程不安全的
• StringBuffer是线程安全的,StringBuilder是线程不安全的
• Hashtable是线程安全的,HashMap是线程不安全的

总结

多线程两种实现方式

继承thread

• 定义类继承Thread
• 重写run方法
• 把新线程要做的事写在run方法中
• 创建线程对象
• 开启新线程, 内部会自动执行run方法

实现Runnable

• 定义类实现Runnable接口
• 实现run方法
• 把新线程要做的事写在run方法中
• 创建自定义的Runnable的子类对象
• 创建Thread对象, 传入Runnable
• 调用start()开启新线程, 内部会自动调用Runnable的run()方法

多线程的安全问题及解决方案

• 问题:当多线程并发, 有多段代码同时执行时,数据会产生错乱。
• 方案:我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步。

死锁的产生原理

• 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁

多线程两种实现方式的区别

实现原理

继承Thread

• 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法

实现Runnable

• 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法

优缺点

继承Thread

• 好处：可以直接使用Thread类中的方法,代码简单
• 弊端：如果已经有了父类,就不能用这种方法

实现Runnable

• 好处: 即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
• 弊端: 不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

单例设计模式

单例设计模式：保证类在内存中只有一个对象。

如何保证类在内存中只有一个对象呢？

1. 控制类的创建，不让其他类来创建本类的对象。private
2. 在本类中定义一个本类的对象，Singgleton s；
3. 提供公共的访问方式，public static Singleton getInstance(){return s}

单例写法两种

饿汉式 开发用这种方式

package com.heima.singleton;

public class Demo1_Singleton {
    
    

	public static void main(String[] args) {
    
    
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2);// 结果为true
	}

}

/*
 * 饿汉式
 */
class Singleton {
    
    

	// 1、私有构造函数,其它类不能访问该构造函数
	private Singleton() {
    
    
	}

	// 2、创建本类对象
	private static Singleton s = new Singleton();

	// 3、对外提供公共的访问方法
	public static Singleton getInstance() {
    
    
		return s;
	}
}

懒汉式 面试写这种方式，多线程的问题

package com.heima.singleton;

public class Demo2_Singleton {
    
    

	public static void main(String[] args) {
    
    
		Singleton1 s1 = Singleton1.getInstance();
		Singleton1 s2 = Singleton1.getInstance();
		System.out.println(s1 == s2);// 结果为true
	}

}

/*
 * 懒汉式，单例延迟加载模式
 */
class Singleton1 {
    
    
	// 1、私有构造函数
	private Singleton1() {
    
    
	};

	// 声明一个本类的引用
	private static Singleton1 s;

	// 3、对外提供公共的访问方法
	public static Singleton1 getInstance() {
    
    
		if (s == null) {
    
    
			s = new Singleton1();
		}
		return s;
	}
}


饿汉式和懒汉式的区别
1,饿汉式是空间换时间,懒汉式是时间换空间
2,在多线程访问时,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象

第三种格式

class Singleton {
    
    
	//1,私有构造方法,其他类不能访问该构造方法了
	private Singleton(){
    
    }
	//2,声明一个引用
	public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
}

Runtime类

• Runtime类是一个单例类

package com.heima.singleton;

import java.io.IOException;

public class Demo_Runtime {
    
    

	public static void main(String[] args) throws IOException {
    
    
		Runtime r = Runtime.getRuntime(); // 获取运行时对象
		// r.exec("shutdown -s -t 300");
		r.exec("shutdown -a");
	}
}

Timer（掌握）

• Timer类:计时器

package com.heima.singleton;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Demo3_Timer {
    
    
	public static void main(String[] args) throws InterruptedException {
    
    
		Timer t = new Timer();
		// 在指定时间安排指定任务
		// 第一个参数,是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间再重复执行
		t.schedule(new MyTimerTask(), new Date(188, 6, 1, 14, 22, 50), 3000);

		while (true) {
    
    
			Thread.sleep(1000);
			System.out.println(new Date());
		}
	}

}

class MyTimerTask extends TimerTask {
    
    

	@Override
	public void run() {
    
    
		System.out.println("起床背英语单词");
	}
}

两个线程间的通信（掌握）

什么时候需要通信

• 多个线程并发执行时，在默认情况下CPU是随机切换线程的。
• 如果我们希望他们有规律的执行，就可以使用通信，例如每个线程执行一次打印

怎么通信

• 如果希望线程等待，就调用wait()；
• 如果希望唤醒等待的线程，就调用notify()；
• 这两个方法必须在同步代码块中执行，并且使用同步锁对象来调用

package com.heima.thread2;

public class Demo1_Notify {
    
    

	/**
	 * 等待唤醒机制
	 */
	public static void main(String[] args) {
    
    
		final Printer p = new Printer();

		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					try {
    
    
						p.print1();
					} catch (InterruptedException e) {
    
    

						e.printStackTrace();
					}
				}
			}
		}.start();

		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					try {
    
    
						p.print2();
					} catch (InterruptedException e) {
    
    

						e.printStackTrace();
					}
				}
			}
		}.start();
	}

}

// 等待唤醒机制
class Printer {
    
    
	private int flag = 1;

	public void print1() throws InterruptedException {
    
    
		synchronized (this) {
    
    
			if (flag != 1) {
    
    
				this.wait(); // 当前线程等待
			}
			System.out.print("黑");
			System.out.print("马");
			System.out.print("程");
			System.out.print("序");
			System.out.print("员");
			System.out.print("\r\n");
			flag = 2;
			this.notify(); // 随机唤醒单个等待的线程
		}
	}

	public void print2() throws InterruptedException {
    
    
		synchronized (this) {
    
    
			if (flag != 2) {
    
    
				this.wait();
			}
			System.out.print("传");
			System.out.print("智");
			System.out.print("播");
			System.out.print("客");
			System.out.print("\r\n");
			flag = 1;
			this.notify();
		}
	}
}

三个或三个以上线程通信

多个线程通信的问题

• notify()方法是随机唤醒一个线程
• notifyAll()方法是唤醒所有线程
• JDK5之前无法唤醒指定的一个线程
• 如果多个线程之间通信，需要使用notifyAll()通知所有线程，用while来反复判断条件

package com.heima.thread2;

public class Demo2_NotifyAll {
    
    

	public static void main(String[] args) {
    
    

		final Printer2 p2 = new Printer2();
		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					try {
    
    
						p2.print1();
					} catch (InterruptedException e) {
    
    
						e.printStackTrace();
					}
				}
			}
		}.start();

		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					try {
    
    
						p2.print2();
					} catch (InterruptedException e) {
    
    
						e.printStackTrace();
					}
				}
			}
		}.start();

		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					try {
    
    
						p2.print3();
					} catch (InterruptedException e) {
    
    
						e.printStackTrace();
					}
				}
			}
		}.start();
	}
}

/*
 * 1、在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法 
 * 2、为什么wait方法和notify方法定义在Object这类中?
 * 	   因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类中
 * 3、sleep方法和wait方法的区别? 
 * 	  a、sleep方法必须传入参数,参数就是时间,时间到了自动醒来，
 *      wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待
 *    b、sleep方法在同步函数或同步代码块中,不释放锁,睡着了也抱着锁睡 wait方法在同步函数或者同步代码块中,释放锁
 */
class Printer2 {
    
    
	private int flag = 1;

	public void print1() throws InterruptedException {
    
    
		synchronized (this) {
    
    
			while (flag != 1) {
    
    
				this.wait(); 							// 当前线程等待
			}
			System.out.print("黑");
			System.out.print("马");
			System.out.print("程");
			System.out.print("序");
			System.out.print("员");
			System.out.print("\r\n");
			flag = 2;
			// this.notify(); 							//随机唤醒单个等待的线程
			this.notifyAll();
		}
	}

	public void print2() throws InterruptedException {
    
    
		synchronized (this) {
    
    
			while (flag != 2) {
    
    
				this.wait(); 							// 线程2在此等待
			}
			System.out.print("传");
			System.out.print("智");
			System.out.print("播");
			System.out.print("客");
			System.out.print("\r\n");
			flag = 3;
			// this.notify();
			this.notifyAll();
		}
	}

	public void print3() throws InterruptedException {
    
    
		synchronized (this) {
    
    
			while (flag != 3) {
    
    
				this.wait(); 							// 线程3在此等待,if语句是在哪里等待,就在哪里起来
														// while循环是循环判断,每次都会判断标记
			}
			System.out.print("i");
			System.out.print("t");
			System.out.print("h");
			System.out.print("e");
			System.out.print("i");
			System.out.print("m");
			System.out.print("a");
			System.out.print("\r\n");
			flag = 1;
			// this.notify();
			this.notifyAll();
		}
	}
}

JDK1.5新特性互斥锁（掌握）

同步

• 使用ReentrantLock类的lock()和unlock()方法进行同步

通信

• 使用ReentrantLock类的newCondition()方法可以获取Condition对象
• 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
• 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

package com.heima.thread2;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Demo3_ReentrantLock {
    
    

	public static void main(String[] args) {
    
    
		final Printer3 p = new Printer3();

		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					try {
    
    
						p.print1();
					} catch (InterruptedException e) {
    
    

						e.printStackTrace();
					}
				}
			}
		}.start();

		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					try {
    
    
						p.print2();
					} catch (InterruptedException e) {
    
    

						e.printStackTrace();
					}
				}
			}
		}.start();

		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					try {
    
    
						p.print3();
					} catch (InterruptedException e) {
    
    

						e.printStackTrace();
					}
				}
			}
		}.start();
	}

}

class Printer3 {
    
    
	private ReentrantLock r = new ReentrantLock();
	private Condition c1 = r.newCondition();
	private Condition c2 = r.newCondition();
	private Condition c3 = r.newCondition();

	private int flag = 1;

	public void print1() throws InterruptedException {
    
    
		r.lock(); 										// 获取锁
		if (flag != 1) {
    
    
			c1.await();
		}
		System.out.print("黑");
		System.out.print("马");
		System.out.print("程");
		System.out.print("序");
		System.out.print("员");
		System.out.print("\r\n");
		flag = 2;
		// this.notify(); 								//随机唤醒单个等待的线程
		c2.signal();
		r.unlock(); 									// 释放锁
	}

	public void print2() throws InterruptedException {
    
    
		r.lock();
		if (flag != 2) {
    
    
			c2.await();
		}
		System.out.print("传");
		System.out.print("智");
		System.out.print("播");
		System.out.print("客");
		System.out.print("\r\n");
		flag = 3;
		// this.notify();
		c3.signal();
		r.unlock();
	}

	public void print3() throws InterruptedException {
    
    
		r.lock();
		if (flag != 3) {
    
    
			c3.await();
		}
		System.out.print("i");
		System.out.print("t");
		System.out.print("h");
		System.out.print("e");
		System.out.print("i");
		System.out.print("m");
		System.out.print("a");
		System.out.print("\r\n");
		flag = 1;
		c1.signal();
		r.unlock();
	}
}

线程组的概述和使用（了解）

线程组的概述

Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制

默认情况下，所有的线程都属于主线程组。

public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
public final String getName()//通过线程组对象获取他组的名字

我们也可以给线程设置分组

1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
2,创建线程对象
3,Thread(ThreadGroup?group, Runnable?target, String?name) 
4,设置整组的优先级或者守护线程

案例演示

• 自己设定线程组

package com.heima.thread2;

public class Demo4_ThreadGroup {
    
    

	public static void main(String[] args) {
    
    
		// demo1();

		ThreadGroup tg = new ThreadGroup("我是一个新的线程组");// 创建新的线程组
		MyRunnable mr = new MyRunnable();// 创建Runnable的子类对象
		Thread t1 = new Thread(tg, mr, "张三");// 将线程t1放在组中
		Thread t2 = new Thread(tg, mr, "李四");// 将线程t2放在组中

		System.out.println(t1.getThreadGroup().getName());// 获取组名
		System.out.println(t2.getThreadGroup().getName());
	}

	private static void demo1() {
    
    
		MyRunnable mr = new MyRunnable();
		Thread t1 = new Thread(mr, "张三");
		Thread t2 = new Thread(mr, "李四");

		ThreadGroup tg1 = t1.getThreadGroup();
		ThreadGroup tg2 = t2.getThreadGroup();

		System.out.println(tg1.getName());// 默认的是主线程
		System.out.println(tg2.getName());// 默认的是主线程
	}

}

class MyRunnable implements Runnable {
    
    
	public void run() {
    
    
		for (int i = 0; i < 1000; i++) {
    
    
			System.out.println(Thread.currentThread().getName() + "..." + i);
		}
	}
}

线程的五种状态（掌握）

• 看图说话

• 新建、就绪、运行、阻塞、死亡

线程池的概述和使用（了解）

线程池概述

程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池。

内置线程池的使用概述

JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法

* public static ExecutorService newFixedThreadPool(int nThreads)
    创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程
* public static ExecutorService newSingleThreadExecutor()
    创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
* 这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
* Future<?> submit(Runnable task)
* <T> Future<T> submit(Callable<T> task)

使用步骤

1. 创建线程池对象
2. 创建Runnable实例
3. 提交Runnable实例
4. 关闭线程池

案例演示

package com.heima.thread2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo5_Executors {
    
    

	public static void main(String[] args) {
    
    
		ExecutorService pool = Executors.newFixedThreadPool(2);// 创建线程池
		pool.submit(new MyRunnable());// 将线程放进池子里并执行
		pool.submit(new MyRunnable());
		pool.shutdown();// 关闭线程池
	}
}

多线程程序实现的方式3（了解）

• 提交的是Callable

package com.heima.thread2;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Demo6_Callable {
    
    

	public static void main(String[] args) throws InterruptedException, ExecutionException {
    
    
		ExecutorService pool = Executors.newFixedThreadPool(2);// 创建线程池
		Future<Integer> f1 = pool.submit(new MyCallable(100));
		Future<Integer> f2 = pool.submit(new MyCallable(50));
		System.out.println(f1.get());// 5050
		System.out.println(f2.get());// 1275
		pool.shutdown();// 关闭线程池
	}

}

class MyCallable implements Callable<Integer> {
    
    

	private int num;

	public MyCallable(int num) {
    
    
		this.num = num;
	}

	@Override
	public Integer call() throws Exception {
    
    
		int sum = 0;
		for (int i = 1; i <= num; i++) {
    
    
			sum += i;
		}
		return sum;
	}
}

多线程程序实现的方式3的好处和弊端

好处

• 可以有返回值
• 可以抛出异常

弊端

• 代码比较复杂，所以一般不用

---