java笔记——多线程笔记

目录

学习目标：

1.线程简介

普通方法调用和多线程的区别​编辑

Process（进程）与Thread（线程）

  本章核心概念

 2.线程创建

2.1 三种创建方式

 2.2Thread（重点）

2.3Runnable接口（重点）

 例子1：抢火车票

例子2：龟兔赛跑

2.4实现Callable接口（了解）

 2.5静态代理模式

 2.6Lambda表达式

3线程5种状态

         3.1线程停止——stop()

3.2线程休眠——sleep()

3.3线程礼让——Yield()

3.4线程强制执行——Join()

 3.5观测线程状态

3.6.线程的优先级

3.7守护线程——daemon

4.线程的同步

4.1案例：不安全购票 

4.4同步方法及同步块

补充：CopyOnWriteArrayList

4.5死锁

4.6lock锁

synchronized 与Lock的对比

 5.线程通信

 解决方法一：并发协作模型“生产者/消费者模式”--->管程法

 解决方法二：并发协作模型“生产者/消费者模式”--->信号灯法

5.1线程池

 6总结

---

学习目标：

1.线程简介	4.线程同步（重点）
2.线程实现（重点）	5.线程通信问题
3.线程状态	6.高级主题

1.线程简介

普通方法调用和多线程的区别

Process（进程）与Thread（线程）

• 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
• 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。
• 注意:很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

  本章核心概念

• 线程就是独立的执行路径;
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程;
• main()称之为主线程，为系统的入口，用于执行整个程序;
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制;线程会带来额外的开销，如cpu调度时间，并发控制开销。
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

 2.线程创建

2.1 三种创建方式

 

 2.2Thread（重点）

• 自定义线程类继承Thread类
• 重写run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程

package com.study.Thread;
//创建进程方式一：继承Thread类，重写run（）方法
//调用start开启线程
//总结：线程不一定立即执行，有CPU调度安排
public class ThreadDemo extends Thread {
	//run方法线程体
	@Override
	public void run() {
		for(int i=0; i<20; i++) {
			System.out.println("我在看代码---"+i);
		}
	}
	//main线程，主线程
	public static void main(String[] args) {
		//创建一个线程对象
		ThreadDemo threadDemo=new ThreadDemo(); 
		//调用start()方法
		threadDemo.start();
		//两条线程交替执行
		//只是运行速度快，我们感觉是同时执行
		for (int i = 0; i < 20; i++) {
			System.out.println("我在学习多线程---"+i);
		}
	}
}

 练习：

package com.study.Thread;

import java.io.File;
import java.io.IOException;
import java.net.URL;

import org.apache.commons.io.FileUtils;

//练习Thread，实现多线程下载图片
public class ThreadDemo2 extends Thread{
	private String url;//保存图片url
	private String name;//保存图片名称
	//生成构造器函数
	public ThreadDemo2(String url, String name) {
		super();
		this.url = url;
		this.name = name;
	}
	//重写run方法
	@Override
	public void run() {
		WebDownloader webDownloader=new WebDownloader();
		webDownloader.downloader(url, name);
		System.out.println("下载文件名："+name);
	}
	//main函数同时执行我们的run方法
	public static void main(String[] args) {
		ThreadDemo2 td1=new ThreadDemo2("https://img-blog.csdnimg.cn/527507fe3747495eac1332791f42b921.jpeg", "1.jpg");
		ThreadDemo2 td2=new ThreadDemo2("https://img-blog.csdnimg.cn/3d69d81d599c4c8f8c9eaf3b327dec8b.jpeg", "2.jpg");
		ThreadDemo2 td3=new ThreadDemo2("https://img-blog.csdnimg.cn/527507fe3747495eac1332791f42b921.jpeg", "3.jpg");
		td1.start();
		td2.start();
		td3.start();
	}
}
//第一要有一个下载器
class WebDownloader{
	//下载方法
	public void downloader(String url,String name) {
		try {
			FileUtils.copyURLToFile(new URL(url), new File(name));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("IO异常，downloader方法出现问题");
		}
	}
}

2.3Runnable接口（重点）

• 定义MyRunnable类实现Runnable接口
• 实现run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程 

package com.study.Thread;

import java.io.IOException;
import java.nio.CharBuffer;

//创建线程方式2：定义MyRunnable类实现Runnable接口
//实现run()方法，编写线程执行体
//创建线程对象，调用start()方法启动线程
public class RunnableDemo implements Runnable {
	//run方法线程体
		public void run() {
			for(int i=0; i<20; i++) {
				System.out.println("我在看代码---"+i);
			}
		}
		//main线程，主线程
		public static void main(String[] args) {
			//创建Runnable接口的实现类对象
			RunnableDemo runnableDemo =new RunnableDemo();
			//创建一个线程对象，通过线程对象开启我们的线程，代理
//			Thread thread =new Thread(runnableDemo);
//			thread.start();
			//上面两句可以合并为
			new Thread(runnableDemo).start();
			//两条线程交替执行
			//只是运行速度快，我们感觉是同时执行
			for (int i = 0; i < 20; i++) {
				System.out.println("我在学习多线程---"+i);
			}
		}
	
}

 小结：

• 继承Thread类
  • 子类继承Thread类具备多线程能力
  • 启动线程:子类对象. start()
  • 不建议使用:避免OOP单继承局限性

• 实现Runnable接口
  • 实现接口Runnable具有多线程能力
  • 启动线程:传入目标对象+Thread对象.start()
  • 推荐使用:避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

 例子1：抢火车票

package com.study.Thread;

import java.util.jar.Attributes.Name;

/*
 * 练习抢火车票
 * */
//发现问题：多个进程同时操作同一个资源，线程不安全，数据安全
public class RunnableDemo2  implements Runnable{
	//设置火车票数
	private int tickrtNums=10;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {//设置一个无限循环
			if (tickrtNums<=0) {
				break;
			}
			//模拟延时
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"-->抢到了第"+tickrtNums--+"票");
		}//Thread.currentThread().getName()可以得到线程的名称
	}
	public static void main(String[] args) {
		RunnableDemo2 runnableDemo2=new RunnableDemo2();
		new Thread(runnableDemo2,"张三").start();
		new Thread(runnableDemo2,"李四").start();
		new Thread(runnableDemo2,"王五").start();
		new Thread(runnableDemo2,"黄牛").start();
	}
}

例子2：龟兔赛跑

package com.study.Thread;
/*
 * 模拟龟兔赛跑
 * */
public class Race implements Runnable {
	//创建胜利者常量
	private static String winner;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		for (int i = 0; i <= 100; i++) {
			//模拟兔子休息
			if (Thread.currentThread().getName().equals("兔子")&&i%10==0) {
				//判断那个线程是兔子,设置每10步休息一次
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			//判断比赛结束没
			boolean flag=gameover(i);
			if (flag) {
				break;//flag为真，比赛结束
			}
			System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"米");
		}
	}
	//写判断是否完成比赛与得出谁是胜利者的一个方法
	private boolean gameover(int steps) {//传递一个步数参数
		//判断是否有胜利者
		if (winner!=null) {//已经存在胜利者
			return true;
		}else {
			if (steps>=100) {
				winner=Thread.currentThread().getName();//得到胜利者的名字
				System.out.println("我们的胜利者是："+winner);
				return true;
			}
		}
		return false;//都没有比赛继续
	}
	public static void main(String[] args) {
		Race race=new Race();//定义赛道
		new Thread(race,"兔子").start();
		new Thread(race,"乌龟").start();
	}
}

2.4实现Callable接口（了解）

1. 实现Callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务 ExecutorService ser = Executors.newFixedThreadPood(1);
5. 提交执行 Future<Boolean> result = ser.submit(t1);
6. 获取结果 boolean r1 = result.get();
7. 关闭服务 ser.shutdownNow();

 Callable的好处：

1. 可以定义返回值
2. 可以抛出异常
3. 有使用公式为上方加粗标红

package com.study.Thread;

import java.io.File;
import java.io.IOException;
import java.net.URL;
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;

import org.apache.commons.io.FileUtils;

/*
 * 线程创建方式三：实现Callable接口
 * */
public class CallableDemo implements Callable<Boolean> {
	private String url;//保存图片url
	private String name;//保存图片名称
	//生成构造器函数
	public CallableDemo(String url, String name) {
		super();
		this.url = url;
		this.name = name;
	}
	//重写run方法
	@Override
	public Boolean call() {
		WebDownloader webDownloader=new WebDownloader();
		webDownloader.downloader(url, name);
		System.out.println("下载文件名："+name);
		return true;
	}
	public static void main(String[] args) {
		CallableDemo td1=new CallableDemo("https://img-blog.csdnimg.cn/527507fe3747495eac1332791f42b921.jpeg", "1.jpg");
		CallableDemo td2=new CallableDemo("https://img-blog.csdnimg.cn/3d69d81d599c4c8f8c9eaf3b327dec8b.jpeg", "2.jpg");
		CallableDemo td3=new CallableDemo("https://img-blog.csdnimg.cn/527507fe3747495eac1332791f42b921.jpeg", "3.jpg");
//		创建执行服务 
		ExecutorService ser = Executors.newFixedThreadPool(3);
//		提交执行 
		Future<Boolean> r1 = ser.submit(td1);
		Future<Boolean> r2 = ser.submit(td2);
		Future<Boolean> r3 = ser.submit(td3);
//		获取结果 
		try {
			boolean rs1 = r1.get();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			boolean rs2 = r2.get();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			boolean rs3 = r3.get();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
//		关闭服务 
		ser.shutdownNow();
	}
}
//这是从thread里面复制的，不在一个包里要加，在不需要
//第一要有一个下载器
//class WebDownloader{
//	//下载方法
//	public void downloader(String url,String name) {
//		try {
//			FileUtils.copyURLToFile(new URL(url), new File(name));
//		} catch (IOException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//			System.out.println("IO异常，downloader方法出现问题");
//		}
//	}
//}

 2.5静态代理模式

静态代理总结

1. 真实对象和代理对象都要实现同一个接口
2. 代理对象要代理真实角色

好处：

1. 代理对象可以做很多真实对象做不了的事情
2. 真实对象专注做自己的事情

package com.study.Thread;

import java.lang.annotation.Target;
/*
 * 静态代理总结
 * 真实对象和代理对象都要实现同一个接口
 * 代理对象要代理真实角色
 * 好处：
 * 代理对象可以做很多真实对象做不了的事情
 * 真实对象专注做自己的事情
 * */
public class StaticProxyDemo {
	public static void main(String[] args) {
		You you=new You();
		//WeddingCompany WeddingCompany=new WeddingCompany(you);
		//WeddingCompany.HappyMarry();可以简写为下面的形式
		new WeddingCompany(new You()).HappyMarry();
		new Thread(()->System.out.println("我爱你")).start();//lambda表达式
	}
}
//定义一个接口结婚
interface Marry{
	//人生四大喜事
	/*
	 * 久旱逢甘露
	 * 他乡遇故知
	 * 洞房花烛夜
	 * 金榜题名时
	 * */
	void HappyMarry();
}
//真实角色去结婚
class You implements Marry{
	@Override
	public void HappyMarry() {
		// TODO Auto-generated method stub
		System.out.println("你结婚了很开心");
	}
	
}
//代理角色，帮助你完成结婚
class WeddingCompany implements Marry{
	//代理谁-》真实的的目标角色
	private Marry target;
	//通过构造传递进来
	public WeddingCompany(Marry target) {
		super();
		this.target = target;
	}

	@Override
	public void HappyMarry() {
		// TODO Auto-generated method stub
		before();//之前
		this.target.HappyMarry();//调用HappyMarry方法
		after();//之后
	}
	private void before() {
		// TODO Auto-generated method stub
		System.out.println("结婚之前，婚庆公司帮你布置现场");
	}
	private void after() {
		// TODO Auto-generated method stub
		System.out.println("结婚之后，婚庆公司找你收尾款");
	}

	
	
}

 2.6Lambda表达式

λ希腊字母表中排序第十一位的字母，英语名称为Lambda 入希腊字母表中排序第十一位的字母，英语名称为Lambda

• 为什么要使用lambda表达式
  • 避免匿名内部类定义过多
  • 可以让代码看起来更简洁
  • 去掉无意义代码，留下核心逻辑
  • 其实质属于函数编程的概念
  • new Thread(()->System.out.println("我爱你")).start();//lambda表达式  

注：只有一行代码的情况下才能简化成一行；前提是接口为函数式接口

• 理解Functional Interface(函数式接口）是学习Java8 lambda表达式的关键所在。
• 函数式接口的定义:
• 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
•  对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

package com.study.Thread;
//使用Lambda表达式，可以是父类或者接口，里面只能有一个抽象方法
public class LambdaDemo2 {
	static class Love2 implements Ilove{

		@Override
		public void love(String a) {
			// TODO Auto-generated method stub
			System.out.println("I Love You-->"+a);
		}
		
	}
	public static void main(String[] args) {
		//1.创建接口对象实现类
		Ilove ilove=new Love();
		ilove.love("创建接口对象实现类");
		//2.静态内部类实现
		ilove=new Love2();
		ilove.love("静态内部类实现");
		//3.内部类实现
		class Love3 implements Ilove{
			@Override
			public void love(String a) {
				// TODO Auto-generated method stub
				System.out.println("I Love You-->"+a);
			}
		}
		ilove =new Love3();
		ilove.love("内部类实现");
		//4.局部内部类实现
		ilove=new Ilove() {
			@Override
			public void love(String a) {
				// TODO Auto-generated method stub
				System.out.println("I Love You-->"+a);
			}
		};
		ilove.love("局部内部类实现");
		//5.使用lambda表达式实现
		ilove=(String a)->{
			System.out.println("I Love You-->"+a);
		};
		ilove.love("lambda表达式实现");
		//简化1.去掉参数返回类型
		ilove=(a)->{
			System.out.println("I Love You-->"+a);
		};
		ilove.love("lambda表达式简化1.去掉参数返回类型");
		//简化2.简化括号
		ilove=a->{
			System.out.println("I Love You-->"+a);
		};
		ilove.love("lambda表达式简化2.简化括号");
		//简化3.简化花括号
		ilove=a->System.out.println("I Love You-->"+a);
		ilove.love("lambda表达式简化3.简化花括号");
		/*
		 * 总结
		 * lambda表达式只能在一行代码的情况下才能简化成为一行
		 * 如果有多行就要用代码块包裹，就是花括号
		 * 使用lambda表达式的前提是接口为函数式接口
		 * 多个参数的也可以使用表达式，但是要去掉参数类型就都要去掉，
		 * 不可以a没有类型，b有类型这个是不可以的
		 * 二者都去掉参数类型才可以使用去掉括号的表达式
		 * */
	}
}
//定义一个接口
interface Ilove{
	void love(String a);//里面只有一个抽象方法
}
//创建一个实现类
class Love implements Ilove{
	//
	@Override
	public void love(String a) {
		// TODO Auto-generated method stub
		System.out.println("I Love You-->"+a);
	}
	
}

3线程5种状态

线程的五种状态：

 

 线程方法：

 3.1线程停止——stop()

• 不推荐使用JDK提供的stop(); destroy();方法
• 推荐线程自己停止
• 建议使用一个标志位进行终止变量

package com.study.State;
/*
 * 线程停止 
 * 1.建议线程正常停止-->利用次数，不建议死循环
 * 2.建议使用标志位-->设置标志位
 * 3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
 * */
public class StopDemo implements Runnable{
	//设置一个标志位
	private boolean flag=true;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		int i=0;
		while (flag) {
			System.out.println("run...Thread"+i++);
		}
	}
	//设置一个公开的方法阻止线程，转换标志位
	public void stop() {
		this.flag=false;
	}
	public static void main(String[] args) {
		StopDemo stopDemo=new StopDemo();
		new Thread(stopDemo).start();
		
		for (int i = 0; i < 100; i++) {
			System.out.println("main执行了"+i+++"次");
			if (i==95) {
				//设置一个阈值，调用stop方法
				stopDemo.stop();
				System.out.println("线程结束");
			}
		}
	}
}

3.2线程休眠——sleep()

• sleep（时间）指定当前线程阻塞的毫秒数
• sleep存在异常InterruptedException
• sleep时间到达后线程进入就绪状态
• sleep可以模拟网络延时，倒计时等
• 每一个对象都有一个锁，sleep不会释放锁

• package com.study.State;
  
  import java.text.SimpleDateFormat;
  import java.util.Date;
  
  /*
   * 倒计时
   * */
  public class SleepDemo2 {
  	public static void main(String[] args) {
  //		try {
  //			tendown();
  //		} catch (InterruptedException e) {
  //			// TODO Auto-generated catch block
  //			e.printStackTrace();
  //		}
  		Date date=new Date(System.currentTimeMillis());//获取当前世界
  		while (true) {
  			try {
  				Thread.sleep(1000);
  				System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
  				date=new Date(System.currentTimeMillis());
  			} catch (InterruptedException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
  		}
  	}
  	private static void tendown() throws InterruptedException {
  		int num=10;
  		while(true) {
  			System.out.println(num--);
  			Thread.sleep(1000);
  			if (num==0) {
  				break;
  			}
  		}
  	}
  }
  

  3.3线程礼让——Yield()

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让CPU重新调度，礼让不一定成功，看CPU心情

package com.study.State;
/*
 * 线程礼让
 * 礼让不一定成功，看CPU心情
 * */
public class YieldDemo {
	public static void main(String[] args) {
		MyYield myYield=new MyYield();
		new Thread(myYield,"A").start();
		new Thread(myYield,"B").start();
	}
}
class MyYield implements Runnable{

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"线程开始执行");
		Thread.yield();//礼让
		System.out.println(Thread.currentThread().getName()+"线程结束执行");
		
	}
	
}

3.4线程强制执行——Join()

• join合并线程，待此线程执行完成后再执行其他线程，其他线程阻塞
• 可以想象成插队

package com.study.State;
/*
 * 线程强制执行
 * */
public class JionDemo implements Runnable {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 500; i++) {
			System.out.println("vip来了"+i);
		}
	}
	
	public static void main(String[] args) throws InterruptedException {
		//启动线程
		JionDemo jionDemo=new JionDemo();
		Thread thread =new Thread(jionDemo);
		thread.start();
		
		//主线程
		for (int i = 0; i < 1000; i++) {
			if (i==200) {
				thread.join();
			}
			System.out.println("main"+i);
		}
	}
}

 3.5观测线程状态

• 线程状态。 线程可以处于以下状态之一：
  • NEW
    尚未启动的线程处于此状态。
  • RUNNABLE
    在Java虚拟机中执行的线程处于此状态。
  • BLOCKED
    被阻塞等待监视器锁定的线程处于此状态。
  • WAITING
    正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED
    已退出的线程处于此状态。 

package com.study.State;
/*
 * 观察线程状态
 * */
public class StateDemo {
	public static void main(String[] args) throws InterruptedException {
		Thread thread=new Thread(()->{
			for (int i = 0; i < 5; i++) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			System.out.println("线程结束");
		}); 
		//观察状态
		Thread.State state=thread.getState();
		System.out.println(state);//new 创建状态
		//观察启动后
		thread.start();//让线程启动
		state=thread.getState();//更新现在的线程状态
		System.out.println(state);
		while (state!=Thread.State.TERMINATED) {//只要线程不终止，就一直输出状态
			Thread.sleep(100);
			state=thread.getState();//更新现在的线程状态
			System.out.println(state);
			
		}
	}
}

3.6.线程的优先级

• java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，调度器按照优先级决定应该调度哪个线程来执行
• 线程的优先级用数字表示，范围从1~10 
  • Thread.MIN_PRIORITY = 1;
  • Thread.MAX_PRIORITY = 10;
• 使用以下方式改变或获取优先级
  • getPriority().setPriority(int xxx);

优先级低只是意味着获得调度的概率低，并不是高优先级必然先调用 （性能倒置问题）

package com.study.Test;
/*
 * 线程优先级
 * */
public class PriorityDemo {
	public static void main(String[] args) {
		//这是主线程
		System.out.println(Thread.currentThread().getName()+"->"+
				Thread.currentThread().getPriority());
		MyPriority myPriority=new MyPriority();
		Thread t1=new Thread(myPriority);//代理
		Thread t2=new Thread(myPriority);//代理
		Thread t3=new Thread(myPriority);//代理
		Thread t4=new Thread(myPriority);//代理
		Thread t5=new Thread(myPriority);//代理
		Thread t6=new Thread(myPriority);//代理
		//优先级要先设置，在启动否这没用
		t1.start();//不设置，直接启动
		t2.setPriority(1);//先设置优先级1
		t2.start();//再启动
		t3.setPriority(4);
		t3.start();
		t4.setPriority(Thread.MAX_PRIORITY);//设置为最高优先级
		t4.start();
		t5.setPriority(8);
		t5.start();
		t6.setPriority(7);
		t6.start();
	}
}
class MyPriority implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName()+"->"+
		Thread.currentThread().getPriority());//得到线程的名字和优先级
	}
	
}

3.7守护线程——daemon

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 如：后台记录操作日志、监控内存、垃圾回收 etc.

package com.study.State;
/*
 * 守护线程
 * */
public class DaemonDemo {
	public static void main(String[] args) {
		Parent parent=new Parent();
		You you=new You();
		Thread thread=new Thread(parent);
		thread.setDaemon(true);//默认为false，表示为用户线程
		//正常的线程都是用户线程，为true时时守护线程
		thread.start();//守护线程启动
		new Thread(you).start();
	}
}
//国家
class Parent implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			System.out.println("父母保护着你");
		}
	}
}
//你
class You implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 360; i++) {
			System.out.println("你在父母的保护下开心的活着");
		}
		System.out.println("===goodbye World====");
	}
	
}

4.线程的同步

并发：同一个对象被多个线程同时操作

处理多线程问题时，多线程访问一个对象，并且某些线程还想修改这个对象，这时候就需要线程同步。线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕再让下一个线程使用

 线程同步：

由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性﹐在访问时加入锁机制synchronized ,当一个线程获得对象的排它锁,独占资源﹐其他线程必须等待，使用后释放锁即可．存在以下问题:

• 一个线程持有锁会导致其他所有需要此锁的线程挂起；
• 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题；
• 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置﹐引起性能问题。

4.1案例：不安全购票 

package com.study.Synchronization;
/*
 * 不安全的买票
 * 线程不安全 出现同时买到一张票
 * */
public class UnsafeBuyTicket {
	public static void main(String[] args) {
		BuyTicket station=new BuyTicket();//去车站买票
		new Thread(station,"张三").start();
		new Thread(station,"李四").start();
		new Thread(station,"王五").start();
		new Thread(station,"黄牛").start();
	}
	
}

class BuyTicket implements Runnable{
	private int ticket=10;//10张票
	boolean flag=true;//设置一个外部停止方式
	@Override
	public void run() {
		// TODO Auto-generated method stub	
		while (flag) {
			try {
				buy();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	// 买票
	private void buy() throws InterruptedException {
		if (ticket<=0) {
			flag=false;//更新外部停止状态
			return;//没票卖完了
		}else {
			//模拟延时
			Thread.sleep(1000);
			System.out.println(Thread.currentThread().getName()+"买了"+ticket--);//买票
		}
	}
}

 4.2案例：不安全取钱

package com.study.Synchronization;
/*
 * 不安全的取钱
 * 两个人同时取钱
 * */
public class UnsafeBank {
	public static void main(String[] args) {
		Account account=new Account(100, "结婚基金");
		Drawing You =new Drawing(account, 50, "你");
		Drawing girlfriend =new Drawing(account, 100, "girlfriend");
		You.start();
		girlfriend.start();
	}
}
//账户
class Account {
	int money;//钱
	String name;//卡名
	public Account(int money, String name) {
		super();
		this.money = money;
		this.name = name;
	}
}
//银行模拟取款
class Drawing extends Thread{
	Account account;//账户
	int drawingMoney;//取了多少钱
	int nowMoney;//手里的钱
	public Drawing(Account account, int drawingMoney,String name) {
		super(name);
		this.account = account;
		this.drawingMoney = drawingMoney;
	}
	/* (non-Javadoc)
	 * @see java.lang.Thread#run()
	 */
	@Override
	//开始取钱
	public void run() {
		if (account.money-drawingMoney<0) {//判断你可不可以取钱，你要取的钱超出账户余额
			System.out.println(Thread.currentThread().getName()+"卡内余额不足");
			return;
		}
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//取完钱后，更新账户余额
		account.money=account.money-drawingMoney;
		//取完钱后，现在手里一共多少钱
		nowMoney=drawingMoney+nowMoney;//取得钱+之前手里的钱
		System.out.println(account.name+"余额为："+account.money);
		//Thread.currentThread().getName()=this.getName()
		//Drawing继承了Thread的方法所以Thread.currentThread()等价于this
		System.out.println(this.getName()+"手里的钱"+nowMoney);
	}
	
}

4.3案例：不安全线程

package com.study.Synchronization;

import java.util.ArrayList;
import java.util.List;

/*
 * 不安全线程的集合
 * */
public class UnsafeList {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		for (int i = 0; i < 10000; i++) {
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}).start();
		}
		try {
			Thread.sleep(30000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(list.size());
	}
}
package com.study.Synchronization;

import java.util.ArrayList;
import java.util.List;

/*
 * 不安全线程的集合
 * */
public class UnsafeList {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		for (int i = 0; i < 10000; i++) {
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}).start();
		}
		try {
			Thread.sleep(30000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(list.size());
	}
}

4.4同步方法及同步块

• 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块

  同步方法 public synchronized void method(int args){ }

• synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

同步方法的弊端：若将一个大的方法申明synchronized为将会影响效率

•  同步块:synchronized (Obj ){}
• Obj称之为同步监视器
  • 同步块:synchronized (Obj ){}Obj称之为同步监视器
  • 同步方法中无需指定同步监视器﹐因为同步方法的同步监视器就是this ,就是这个对象本身，或者是class [反射中讲解]
• 同步监视器的执行过程
  • 1.第一个线程访问,锁定同步监视器﹐执行其中代码．
  • 2．第二个线程访问﹐发现同步监视器被锁定﹐无法访问．
  • 3．第一个线程访问完毕﹐解锁同步监视器．
  • 4．第二个线程访问,发现同步监视器没有锁﹐然后锁定并访问

package com.study.Synchronization;
/*
 * 不安全的买票
 * 线程不安全 出现同时买到一张票
 * */
public class UnsafeBuyTicket {
	public static void main(String[] args) {
		BuyTicket station=new BuyTicket();//去车站买票
		new Thread(station,"张三").start();
		new Thread(station,"李四").start();
		new Thread(station,"王五").start();
		new Thread(station,"黄牛").start();
	}
	
}

class BuyTicket implements Runnable{
	private int ticket=10;//10张票
	boolean flag=true;//设置一个外部停止方式
	@Override
	public void run() {
		// TODO Auto-generated method stub	
		while (flag) {
			try {
				buy();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	//synchronized同步方法，锁的是this
	// 买票
	private  synchronized void buy() throws InterruptedException {
		if (ticket<=0) {
			flag=false;//更新外部停止状态
			return;//没票卖完了
		}else {
			//模拟延时
			Thread.sleep(100);
			System.out.println(Thread.currentThread().getName()+"买了"+ticket--);//买票
		}
	}
}

package com.study.Synchronization;
/*
 * 不安全的取钱
 * 两个人同时取钱
 * */
public class UnsafeBank {
	public static void main(String[] args) {
		Account account=new Account(300, "结婚基金");
		Drawing You =new Drawing(account, 50, "你");
		Drawing girlfriend =new Drawing(account, 100, "girlfriend");
		You.start();
		girlfriend.start();
	}
}
//账户
class Account {
	int money;//钱
	String name;//卡名
	public Account(int money, String name) {
		super();
		this.money = money;
		this.name = name;
	}
}
//银行模拟取款
class Drawing extends Thread{
	Account account;//账户
	int drawingMoney;//取了多少钱
	int nowMoney;//手里的钱
	public Drawing(Account account, int drawingMoney,String name) {
		super(name);
		this.account = account;
		this.drawingMoney = drawingMoney;
	}
	/* (non-Javadoc)
	 * @see java.lang.Thread#run()
	 */
	@Override
	//开始取钱
	//synchronized, 默认锁的是this.
	//锁的对象是变化的量，需要增删改的对象
	public void run() {
		synchronized (account) {
			if (account.money-drawingMoney<0) {//判断你可不可以取钱，你要取的钱超出账户余额
				System.out.println(Thread.currentThread().getName()+"卡内余额不足");
				return;
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//取完钱后，更新账户余额
			account.money=account.money-drawingMoney;
			//取完钱后，现在手里一共多少钱
			nowMoney=drawingMoney+nowMoney;//取得钱+之前手里的钱
			System.out.println(account.name+"余额为："+account.money);
			//Thread.currentThread().getName()=this.getName()
			//Drawing继承了Thread的方法所以Thread.currentThread()等价于this
			System.out.println(this.getName()+"手里的钱"+nowMoney);
		}
		}
	
}

package com.study.Synchronization;

import java.util.ArrayList;
import java.util.List;

/*
 * 不安全线程的集合
 * */
public class UnsafeList {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		for (int i = 0; i < 10000; i++) {
			new Thread(()->{
				synchronized (list) {
					list.add(Thread.currentThread().getName());
				}
				
			}).start();
		}
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(list.size());
	}
}

补充：CopyOnWriteArrayList

它相当于线程安全的ArrayList。和ArrayList一样，它是个可变数组；但是和ArrayList不同。效果于synchronized相同。

package com.study.Synchronization;

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合
public class JUCDemo {
	public static void main(String[] args) {
		CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();
		for (int i = 0; i < 10000; i++) {
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}) .start();
		}
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

4.5死锁

• 多个线程各自占有一些共享资源﹐并且互相等待其他线程占有的资源才能运行﹐而导致两个或者多个线程都在等待对方释放资源﹐都停止执行的情形.某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。

死锁的避免方法：

• 产生死锁的四个必要条件

  • 互斥：一个资源每次只能被一个进程使用
  • 请求与保持：一个进程因请求资源而阻塞时，对已获得的资源保持不放
  • 不剥夺：进程已获得的资源，在未用完之前，不能强行剥夺
  • 循环等待：若干进程之间形成一种头尾相接的循环等待资源关系 

package com.study.Synchronization;
/*
 * 死锁，多个线程互相抱着对方需要的资源，然后形成僵持的现象
 * 一个进程里不要同时操作两个以上的锁
 * */
public class LockDemo {
	public static void main(String[] args) {
		Makeup g1=new Makeup(0, "小红");
		Makeup g2=new Makeup(1, "小花");
		g1.start();
		g2.start();
	}
}
//口红
class Lipstick{}
//镜子
class mirror{}
class Makeup extends Thread{
	//所需的资源只有一份，用static来保证只有一份
	static Lipstick lipstick=new Lipstick();
	static mirror mirror=new mirror();
	int choice;//选择
	String girlName;// 使用化妆品的人
	
	public Makeup(int choice, String girlName) {
		super();
		this.choice = choice;
		this.girlName = girlName;
	}

	/* (non-Javadoc)
	 * @see java.lang.Thread#run()
	 */
	@Override
	//使用化妆方法
	public void run() {
		// TODO Auto-generated method stub
		try {
			makeup();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//化妆方法
	//化妆，互相持有对方的锁，就是需要拿到对方的资源
	private void makeup () throws InterruptedException {
		if (choice==0) {
			synchronized (lipstick) {//获得口红的锁
				System.err.println(this.girlName+"拿到了口红");
				Thread.sleep(1000);//一秒后想拿到镜子
				/*会死锁的情况
				 * synchronized (lipstick) {
						System.err.println(this.girlName+"拿到了口红");
					}
				 * */
				}//要想不死锁，就不要抱着对方的锁
			synchronized (mirror) {
				System.err.println(this.girlName+"拿到了镜子");
				}
			}else {
				synchronized (mirror) {//获得镜子的锁
					System.err.println(this.girlName+"拿到了镜子");
					Thread.sleep(2000);//一秒后想拿到口红
					/*会死锁的情况
					 * synchronized (lipstick) {
					System.err.println(this.girlName+"拿到了口红");
				}
					 * */
			}
				synchronized (lipstick) {
					System.err.println(this.girlName+"拿到了口红");
				}
		}
	}
}

4.6lock锁

公式：

class A{
  private final ReentrantLock lock = new ReenTrantLock();
  public void m(){
    lock.lock();
    try{
      // 保证线程安全的代码
    }
    finally{
			lock.unlock();
      // 如果同步代码有异常，要将unlock()写入finally语句块 
    }
  }
}

 案例：

package com.study.Synchronization;

import java.util.concurrent.locks.ReentrantLock;

/*
 * Lock锁
 * */
public class LockDemo2 {
	public static void main(String[] args) {
		ticket ticket=new ticket();
		new Thread(ticket).start();
		new Thread(ticket).start();
		new Thread(ticket).start();
	}
}
class ticket implements Runnable {
	private int ticket=10;//10张票
	private final ReentrantLock lock=new ReentrantLock();
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			
			try {
				lock.lock();//加锁
				if (ticket>=0) {
					try {
						Thread.sleep(1000);
						System.out.println(ticket--);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				}else {
					break;
				}
			} finally {
				// TODO: handle finally clause
				//解锁
				lock.unlock();
			}
		}
	}
}

synchronized 与Lock的对比

• Lock是显示锁，需要手动开启和关闭，synchronized为隐式锁，出了作用域自动释放
• lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用lock锁，jvm将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性
• 优先使用顺序
  • Lock > 同步代码快（已经进入方法体，分配了相应资源）> 同步方法(在方法体之外)

 5.线程通信

线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

• 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，有需要马上通知消费者消费
• 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
• 在生产者消费者问题中，仅有synchronized是不够的
  • synchronized可组织并发更新同一个共享资源，实现了同步
  • synchronized不能用来实现不同线程之间的消息传递（通信）

 

Java提供了几个方法解决线程之间的通信问题

方法名	作用
wait()	表示线程一直等待，直到其他线程通知，与sleep（）不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程优先调度

注意： 均是Object类的方法，都只能在同步方法或者同步代码快中使用，否则会抛出异常 IllegalMonitorStateException 

 解决方法一：并发协作模型“生产者/消费者模式”--->管程法

• 生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
• 消费者：负责处理数据的模块（可能是方法、对象、线程、进程）
• 缓冲区：消费者不能直接使用生产者的数据，利用中间“缓冲区”

生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据 

 

package com.study.Resolvent;
/*
 * 管程法
 * 生产者与消费者模型——>利用缓冲区解决
 * */
public class ProductionAndConsumption {
	public static void main(String[] args) {
		SyContainer syContainer=new SyContainer();
		new Production(syContainer).start();
		new Consumption(syContainer).start();
	}
}
//生产者
class Production extends Thread{
	SyContainer container;

	public Production(SyContainer container) {
		super();
		this.container = container;
	}

	/* (non-Javadoc)
	 * @see java.lang.Thread#run()
	 */
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i < 100; i++) {	
			container.push(new Chicken(i));
			System.out.println("生产了"+i+"只鸡");
		}
	}
	
}
//消费者
class Consumption extends Thread{
	SyContainer container;

	public Consumption(SyContainer container) {
		super();
		this.container = container;
	}

	/* (non-Javadoc)
	 * @see java.lang.Thread#run()
	 */
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("消费了-->"+container.pop().id+"只鸡");
		}
	}

}
//产品
class Chicken{
	int id;

	public Chicken(int id) {
		super();
		this.id = id;
	}
	
}
//缓冲区
class SyContainer{
	//需要一个容器，设置容器大小
	Chicken[] chickens=new Chicken[10];
	//对容器计数
	int count=0;
	//生产者存入产品
	public synchronized  Chicken push(Chicken chicken) {
		//如果容器满了，就需要等待消费者消费
		if (count==chickens.length) {
			//通知消费者消费，生产者等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//没有满，就在缓冲区丢入产品
		chickens[count]=chicken;
		count++;
		//可以通知消费者消费了
		this.notifyAll();
		return chicken;
	}
	public synchronized Chicken pop() {
		//判断是否能消费
		if (count==0) {
			//等待生产者生产，消费者等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//可以消费
		count--;
		Chicken chicken=chickens[count];
		//吃完了，通知生产者生产
		this.notifyAll();
		return chicken ;
	}
}

 解决方法二：并发协作模型“生产者/消费者模式”--->信号灯法
 

package com.study.Resolvent;
/*
 * 信号灯法
 * 通过设置标志位解决
 * */
public class SignalLamp {
	public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

// 生产者 --> 演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0){//电视分为节目和广告
                this.tv.play("：新闻联播");
            }else{
                this.tv.play("整点报时");
            }
        }
    }
}
// 消费者 --> 观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

// 产品 --> 节目
class TV{
    // 演员表演，观众等待 T
    // 观众观看，演员等待 F
    String voice; // 表演的节目
    boolean flag = true;
    // 表演
    public synchronized void play(String voice){
    	//演员也要知道观众看完没
        if (!flag){//如果观众在观看，演员等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("演员表演了:" + voice);
        // 通知观众观看
        this.notifyAll(); // 通知唤醒
        this.voice = voice;//表演的节目刷新
        this.flag = !this.flag;//刷新标志位
    }
    // 观看
    public synchronized void watch(){
        if (flag){//演员再表演，观众等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了：" + voice);
        // 通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

5.1线程池

 

package com.study.Resolvent;

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

/*
 * 线程池
 * */
public class PoolDemo {
	public static void main(String[] args) {
		//1.创建范围，创建线程池
		ExecutorService service=Executors.newFixedThreadPool(10);
		//newFixedThreadPool(10);参数为：线程池大小
		//执行
		service.execute(new MyThread());
		service.execute(new MyThread());
		service.execute(new MyThread());
		service.execute(new MyThread());
		service.execute(new MyThread());
		//2.关闭服务
		service.shutdown();
	}
}
class MyThread implements Runnable{

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName());
	}
	
}

 6总结

package Summary;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
 * 总结
 * */
public class NEW {
	 public static void main(String[] args) {
		 	new MyThread1().start();

	        new Thread(new MyThread2()).start();
	        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
	        new Thread(futureTask).start();
	        Integer integer;
			try {
				integer = futureTask.get();
				 System.out.println(integer);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	       
	}
	}

	// 1. 继承Thread类
	class MyThread1 extends Thread{
	    @Override
	    public void run() {
	        System.out.println("My Thread1");
	    }
	}
	// 2. 实现Runnable接口
	class MyThread2 implements Runnable{
	    @Override
	    public void run() {
	        System.out.println("My Thread2");
	    }
	}
	// 3. 实现Callable接口
	class MyThread3 implements Callable<Integer>{
	    public Integer call() throws Exception {
	        System.out.println("My Thread3");
	        return 100;
	    }
}