Java基础5多线程技术

最新推荐文章于 2023-05-31 10:09:11 发布

A记录学习路线

最新推荐文章于 2023-05-31 10:09:11 发布

阅读量390

点赞数 2

分类专栏： Java语言基础

Java语言基础专栏收录该内容

30 篇文章 0 订阅

订阅专栏

11.1 基本概念

多线程是Java语言的重要特性，大量应用于网络编程、服务器端程序的开发，最常见的UI界面底层原理、操作系统底层原理都大量使用了多线程。
我们可以流畅的点击软件或者游戏中的各种按钮，其实，底层就是多线程的应用。UI界面的主线程绘制界面，如果有一个耗时的操作发生则启动新的线程，完全不影响主线程的工作。当这个线程工作完毕后，再更新到主界面上。
我们可以上百人、上千人、上万人同时访问某个网站，其实，也是基于网站服务器的多线程原理。如果没有多线程，服务器处理速度会极大降低。
多线程应用于计算机的各个方面，但是对于初学者，我们只需掌握基本的概念即可。在入门阶段，暂时没有必要钻研过深。

11.1.1 程序

“程序(Program)”是一个静态的概念，一般对应于操作系统中的一个可执行文件，比如：我们要启动酷狗听音乐，则对应酷狗的可执行程序。当我们双击酷狗，则加载程序到内存中，开始执行该程序，于是产生了“进程”。

11.1.2 进程

执行中的程序叫做进程(Process)，是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如：我们在用酷狗听音乐，也可以使用eclipse写代码，也可以同时用浏览器查看网页。进程具有如下特点：
1.进程是程序的一次动态执行过程，占用特定的地址空间。
2.每个进程由3部分组成：cpu、data、code。每个进程都是独立的，保有自己的cpu时间，代码和数据，即便用同一份程序产生好几个进程，它们之间还是拥有自己的这3样东西，这样的缺点是：浪费内存，cpu的负担较重。
3.多任务(Multitasking)操作系统将CPU时间动态地划分给每个进程，操作系统同时执行多个进程，每个进程独立运行。以进程的观点来看，它会以为自己独占CPU的使用权。
4.进程的查看
Windows系统: Ctrl+Alt+Del，启动任务管理器即可查看所有进程。
Unix系统: ps or top。
在这里插入图片描述

11.1.3 线程

一个进程可以产生多个线程。同多个进程可以共享操作系统的某些资源一样，同一进程的多个线程也可以共享此进程的某些资源(比如：代码、数据)，所以线程又被称为轻量级进程(lightweight process)。
1.一个进程内部的一个执行单元，它是程序中的一个单一的顺序控制流程。
2.一个进程可拥有多个并行的(concurrent)线程。
3.一个进程中的多个线程共享相同的内存单元/内存地址空间，可以访问相同的变量和对象，而且它们从同一堆中分配对象并进行通信、数据交换和同步操作。
4.由于线程间的通信是在同一地址空间上进行的，所以不需要额外的通信机制，这就使得通信更简便而且信息传递的速度也更快。
5.线程的启动、中断、消亡，消耗的资源非常少。
在这里插入图片描述

11.1.4 线程和进程的区别

1.每个进程都有独立的代码和数据空间(进程上下文)，进程间的切换会有较大的开销。
2.线程可以看成是轻量级的进程，属于同一进程的线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换的开销小。
3.线程和进程最根本的区别在于：进程是资源分配的单位，线程是调度和执行的单位。
4.多进程: 在操作系统中能同时运行多个任务(程序)。
5.多线程: 在同一应用程序中有多个顺序流同时执行。
6.线程是进程的一部分，所以线程有的时候被称为轻量级进程。
7.一个没有线程的进程是可以被看作单线程的，如果一个进程内拥有多个线程，进程的执行过程不是一条线(线程)的，而是多条线(线程)共同完成的。
8.系统在运行的时候会为每个进程分配不同的内存区域，但是不会为线程分配内存(线程所使用的资源是它所属的进程的资源)，线程组只能共享资源。那就是说，除了CPU之外(线程在运行的时候要占用CPU资源)，计算机内部的软硬件资源的分配与线程无关，线程只能共享它所属进程的资源。

11.1.5 进程与程序的区别

程序是一组指令的集合，它是静态的实体，没有执行的含义。而进程是一个动态的实体，有自己的生命周期。一般说来，一个进程肯定与一个程序相对应，并且只有一个，但是一个程序可以有多个进程，或者一个进程都没有。除此之外，进程还有并发性和交往性。简单地说，进程是程序的一部分，程序运行的时候会产生进程。

11.2 Java中如何实现多线程

在Java中使用多线程非常简单，我们先学习如何创建和使用线程，然后再结合案例深入剖析线程的特性。
在这里插入图片描述
少用继承多用实现

Runnable

在这里插入图片描述
只有 thread才具有和cpu直接打交道的能力，即启动start()

创建线程一

package com.sxt.thread;
/**
 * 创建线程方式一:
 * 1、创建：继承Thread+重写run
 * 2、启动: 创建子类对象 + start
 *
 */
public class StartThread extends Thread{
	/**
	 * 线程入口点
	 */
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println("一边听歌");
		}
	}
	public static void main(String[] args) {			
		//创建子类对象
		StartThread st =new StartThread();
		//调用子类对象的start()方法来启动 
		st.start(); //开启一个线程，交给CPU去调，不保证立即运行 cpu调用
		//st.run(); //普通方法调用，这时候呢，就必须听歌才能敲完代码
		for(int i=0;i<20;i++) {
			System.out.println("一边coding");
		}
	}

}

run()方法自己会去调用start()方法

在这里插入图片描述

图片下载的例子：
借用FileUtils
WebDownloader.java

package com.sxt.thread;

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

import org.apache.commons.io.FileUtils;

/**
 * 下载图片
 */
public class WebDownloader {
	/**
	 * 下载
	 * @param url
	 * @param name
	 */
	public void download(String url,String name) {
		try {
			FileUtils.copyURLToFile(new URL(url), new File(name));
		} catch (MalformedURLException e) {
			e.printStackTrace();
			System.out.println("不合法的url");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("下载失败"); 
		}
	}
}

TDownloader.java

package com.sxt.thread;

public class TDownloader extends Thread {
	private String url; //远程路径
	private String name;  //存储名字
	
	public TDownloader(String url, String name) {//构造器
		this.url = url; 
		this.name = name;
	}

	@Override
	public void run() {//线程体中
		WebDownloader wd =new WebDownloader();
		wd.download(url, name);		
		System.out.println(name);
	}
	
	public static void main(String[] args) {
		TDownloader td1 =new TDownloader("http://upload.news.cecb2b.com/2014/0511/1399775432250.jpg","phone.jpg");
		TDownloader td2 =new TDownloader("http://p1.pstatp.com/large/403c00037462ae2eee13","spl.jpg");
		TDownloader td3 =new TDownloader("http://5b0988e595225.cdn.sohucs.com/images/20170830/d8b57e0dce0d4fa29bd5ef014be663d5.jpeg","success.jpg");
		
		//启动三个线程
		td1.start();
		td2.start();
		td3.start();
	}
}

在这里插入图片描述

创建线程二：
在这里插入图片描述
推荐这种方式
启动线程要借用Thread类
StartRun.java

package com.sxt.thread;
/**
 * 创建线程方式二:
 * 1、创建：实现Runnable+重写run
 * 2、启动: 创建实现类对象 +Thread对象+ start
 * 
 * 推荐: 避免单继承的局限性，优先使用接口
 * 方便共享资源
 *
 */
public class StartRun implements Runnable{
	/**
	 * 线程入口点
	 */
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println("一边听歌");
		}
	}
	public static void main(String[] args) {			
		/*//创建实现类对象
		StartRun sr =new StartRun();
		//创建代理类对象
		Thread t =new Thread(sr);
		//启动 
		t.start(); //不保证立即运行 cpu调用
*/		
		new Thread(new StartRun()).start();//合三为一简化操作。匿名使用，一个对象只用一次
		//st.run(); //普通方法调用
		for(int i=0;i<20;i++) {
			System.out.println("一边coding");
		}
	}

}

例子中的使用
IDownloader.java

package com.sxt.thread;

public class IDownloader implements Runnable{
	private String url; //远程路径
	private String name;  //存储名字
	
	public IDownloader(String url, String name) {
		this.url = url; 
		this.name = name;
	}

	@Override
	public void run() {
		WebDownloader wd =new WebDownloader();
		wd.download(url, name);		
		System.out.println(name);
	}
	
	public static void main(String[] args) {
		IDownloader td1 =new IDownloader("http://upload.news.cecb2b.com/2014/0511/1399775432250.jpg","phone.jpg");
		IDownloader td2 =new IDownloader("http://p1.pstatp.com/large/403c00037462ae2eee13","spl.jpg");
		IDownloader td3 =new IDownloader("http://5b0988e595225.cdn.sohucs.com/images/20170830/d8b57e0dce0d4fa29bd5ef014be663d5.jpeg","success.jpg");
		
		//启动三个线程
		new Thread(td1).start();
		new Thread(td2).start();
		new Thread(td3).start();
	}
}

在这里插入图片描述
Runnale
对同一个资源可以有多个代理
多线程抢票龟兔赛跑
Web12306.java

package com.sxt.thread;
/**
 * 共享资源,并发(要保证线程安全，后期会讲)
 *
 */
public class Web12306 implements Runnable{
	//票数
	private int ticketNums = 99;
	
	@Override
	public void run() {
		while(true) {
			if(ticketNums<0) {
				break;
			}
			try {
				Thread.sleep(200);//模拟网络延时，睡200ms再去执行，可能会出现负数，并发的问题
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);//这里知道谁运行的我，获得线程代理的名字
		}
	}
	public static void main(String[] args) {
		//一份资源
		Web12306 web =new Web12306();
		System.out.println(Thread.currentThread().getName());//这里是main
		//多个代理，如何区分多个代理呢，加名字
		new Thread(web,"码畜").start();
		new Thread(web,"码农").start();
		new Thread(web,"码蟥").start();;
	}
}

模拟龟兔赛跑例子

package com.sxt.thread;
/**
 * 模拟龟兔赛跑
 *
 */
public class Racer implements Runnable{
	private  String winner;//胜利者
	@Override
	public void run() {
		for(int steps =1;steps<=100;steps++) {	//假设有100步	
			//模拟休息
			if(Thread.currentThread().getName().equals("rabbit") && steps%10==0) {//如果你是兔子，就让你延时，没走10步睡一下
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+"-->"+steps);
			//比赛是否结束，每走一步看看比赛是否结束
			boolean flag = gameOver(steps);
			if(flag) {
				break;
			}
		}
	}
	private boolean gameOver(int steps) {//谁先达到100步谁就胜利
		if(winner!=null) { //存在胜利者
			return true;
		}else {
			if(steps ==100) {
				winner = Thread.currentThread().getName();//
				System.out.println("winner==>"+winner);
				return true;
			}
		}
		return false;
	}
	
	public static void main(String[] args) {
		Racer racer = new Racer();//方便共享资源，一条赛道大家都去竞争
		new Thread(racer,"tortoise").start();
		new Thread(racer,"rabbit").start();
	}
}

在这里插入图片描述

乌龟和兔子各走各的
加上延时后

了解Callale
在这里插入图片描述
并发领域的JUC编程
run()方法不能抛出异常和返回返回返回值
这里能

需要借助服务、线程池
CDownloader.java

package com.sxt.thread;

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;
/**
 * 了解创建线程的方式三: 
 * 
*   实现Callable接口，重写call方法
 *
 */
public class CDownloader implements Callable<Boolean>{
	private String url; //远程路径
	private String name;  //存储名字
	
	public CDownloader(String url, String name) {
		this.url = url; 
		this.name = name;
	}

	@Override
	public Boolean call() throws Exception {
		WebDownloader wd =new WebDownloader();
		wd.download(url, name);		
		System.out.println(name);
		return true;
	}
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CDownloader cd1 =new CDownloader("http://upload.news.cecb2b.com/2014/0511/1399775432250.jpg","phone.jpg");
		CDownloader cd2 =new CDownloader("http://p1.pstatp.com/large/403c00037462ae2eee13","spl.jpg");
		CDownloader cd3 =new CDownloader("http://5b0988e595225.cdn.sohucs.com/images/20170830/d8b57e0dce0d4fa29bd5ef014be663d5.jpeg","success.jpg");
		
		//创建执行服务: 
		ExecutorService  ser=Executors.newFixedThreadPool(3);
		//提交执行: 
		Future<Boolean> result1 =ser.submit(cd1) ;
		Future<Boolean> result2 =ser.submit(cd2) ;
		Future<Boolean> result3 =ser.submit(cd3) ;
		//获取结果:  
		boolean r1 =result1.get();
		boolean r2 =result1.get();
		boolean r3 =result1.get();
		System.out.println(r3);
		//关闭服务:  
		ser.shutdownNow();

	}
}

CRacer.java

package com.sxt.thread;

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 CRacer implements Callable<Integer>{
	private  String winner;//胜利者
	@Override
	public Integer call() throws Exception {
		for(int steps =1;steps<=100;steps++) {		
			//模拟休息
			if(Thread.currentThread().getName().equals("pool-1-thread-1") && steps%10==0) {
				Thread.sleep(100);
			}
			System.out.println(Thread.currentThread().getName()+"-->"+steps);
			//比赛是否结束
			boolean flag = gameOver(steps);
			if(flag) {
				return steps;
			}
		}
		return null;
	}
	private boolean gameOver(int steps) {
		if(winner!=null) { //存在胜利者
			return true;
		}else {
			if(steps ==100) {
				winner = Thread.currentThread().getName();
				System.out.println("winner==>"+winner);
				return true;
			}
		}
		return false;
	}
	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CRacer racer = new CRacer();
		//创建执行服务: 
		ExecutorService  ser=Executors.newFixedThreadPool(2);
		//提交执行: 
		Future<Integer> result1 =ser.submit(racer) ;
		Future<Integer> result2 =ser.submit(racer) ;
		//获取结果:  
		Integer r1 =result1.get();
		Integer r2 =result2.get();
		System.out.println(r1+"-->"+r2);
		//关闭服务:  
		ser.shutdownNow();
	}
}

在这里插入图片描述

11.2.1 通过继承Thread类实现多线程

继承Thread类实现多线程的步骤：
1.在Java中负责实现线程功能的类是java.lang.Thread 类。
2.可以通过创建 Thread的实例来创建新的线程。
3.每个线程都是通过某个特定的Thread对象所对应的方法run( )来完成其操作的，方法run( )称为线程体。
4.通过调用Thread类的start()方法来启动一个线程。

【示例11-1】通过继承Thread类实现多线程

public class TestThread extends Thread {//自定义类继承Thread类
    //run()方法里是线程体
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName() + ":" + i);//getName()方法是返回线程名称
        }
    }
 
    public static void main(String[] args) {
        TestThread thread1 = new TestThread();//创建线程对象
        thread1.start();//启动线程
        TestThread thread2 = new TestThread();
        thread2.start();
    }
}

执行结果如图11-3所示：
在这里插入图片描述
此种方式的缺点：如果我们的类已经继承了一个类(如小程序必须继承自 Applet 类)，则无法再继承 Thread 类。

11.2.2 通过Runnable接口实现多线程

在开发中，我们应用更多的是通过Runnable接口实现多线程。这种方式克服了11.2.1节中实现线程类的缺点，即在实现Runnable接口的同时还可以继承某个类。所以实现Runnable接口的方式要通用一些。

【示例11-2】通过Runnable接口实现多线程

public class TestThread2 implements Runnable {//自定义类实现Runnable接口；
    //run()方法里是线程体；
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
    public static void main(String[] args) {
        //创建线程对象，把实现了Runnable接口的对象作为参数传入；
        Thread thread1 = new Thread(new TestThread2());
        thread1.start();//启动线程；
        Thread thread2 = new Thread(new TestThread2());
        thread2.start();
    }
}

执行结果与示例11-1运行效果图(图11-3)类似。

静态代理设计模式

我们使用实现runnable接口重写run方法启动线程时，必须借用Thread对象，这个对象就是代理对象
在这里插入图片描述
StaticProxy.java

package com.sxt.thread;
/**
 * 静态代理
 * 公共接口:
 * 1、真实角色
 * 2、代理角色
 * 真实角色和代理对象 都先实现了结婚接口
 *
 */
public class StaticProxy {
	public static void main(String[] args) {
		new WeddingCompany(new You()).happyMarry();
		
		//new Thread(线程对象).start();
	}
}
interface Marry{
	void happyMarry();
}
//真实角色
class You implements Marry{

	@Override
	public void happyMarry() {
		System.out.println("you and 嫦娥终于奔月了....");
	}
	
}
//代理角色
class WeddingCompany implements Marry{//代理不结婚
	//真实角色
	private Marry target;
	public WeddingCompany(Marry target) {
			this.target = target;
	}
	@Override
	public void happyMarry() {
		ready();
		this.target.happyMarry();
		after();
	}
	
	private void ready() {
		System.out.println("布置猪窝。。。。");
	}
	private void after() {
		System.out.println("闹玉兔。。。。");
	}
}

代理模式以后用来记日志用的

推导lamda简化线程

在这里插入图片描述
用的线程比较少，只关注于线程体
LambdaThread.java

package com.sxt.thread;
/**
 * Lambda表达式 简化线程(用一次)的使用
 *
 */
public class LambdaThread {
	//1静态内部类，随着外部类的加载而加载
	static class Test implements Runnable{		
		public void run() {
			for(int i=0;i<20;i++) {
				System.out.println("一边听歌");
			}
		}
	}
	public static void main(String[] args) {			
		//new Thread(new Test()).start();	静态内部类的使用	
		
		//2局部内部类，把类丢到方法内部来
		class Test2 implements Runnable{		
			public void run() {
				for(int i=0;i<20;i++) {
					System.out.println("一边听歌");
				}
			}
		}		
		new Thread(new Test2()).start();//局部内部类的使用
		
		//3匿名内部类 必须借助接口或者父类
		new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<20;i++) {
					System.out.println("一边听歌");
				}
			}
		}).start();
		
		//4jdk8 简化  lambda表达式  只需要关注线程体，删掉了接口名删掉了方法名，只需要关注你传什么参数，实现什么方法
		new Thread(()-> {
				for(int i=0;i<20;i++) {
					System.out.println("一边听歌");
				}
			}
		).start();
		
	}

}

LambdaTest01.java

package com.sxt.thread;
/**
 * lambda推导，没有参数，没有返回值
 * 
 *
 */
public class LambdaTest01 {
	//2静态内部类
	static class Like2 implements ILike{
		public void lambda() {
			System.out.println("i like lambda2 ");
		}
		
	}
	public static void main(String[] args) {
		ILike like = new Like();
		like.lambda();//外部类的使用
		
		like = new Like2();
		like.lambda();//内部类的使用
		
		//3方法内部类
		class Like3 implements ILike{
			public void lambda() {
				System.out.println("i like lambda3 ");
			}
			
		}
		like = new Like3();
		like.lambda();//方法内部类的使用
		
		//4匿名内部类
		like = new ILike() {
			public void lambda() {
				System.out.println("i like lambda4 ");
			}
		};
		like.lambda();//匿名内部类的使用
		
		//5lambda
		like = ()-> {
			System.out.println("i like lambda5 ");
		};
		like.lambda();
		
		
		/*
		 *lambda推导必须存在类型，以上是like
		()-> {
			System.out.println("i like lambda5 ");
		}.lambda();//这样不对
		*/
	}
}
interface ILike{
	void lambda();
}
//1外部类
class Like implements ILike{

	@Override
	public void lambda() {
		System.out.println("i like lambda ");
	}
	
}

LambdaTest02.java

package com.sxt.thread;
/**
 * lambda推导 +参数
 * 
 *
 */
public class LambdaTest02 {
	
	public static void main(String[] args) {
		ILove love =(int a) -> {//只要把方法 拷贝过来，不需要方法名
			System.out.println("i like lambda -->"+a);
		};
		love.lambda(100);
		
		//简化
		love =(a) -> {//类型也可以拿掉
			System.out.println("i like lambda -->"+a);
		};
		love.lambda(50);
		
		love =a -> {//括号也省略
			System.out.println("i like lambda -->"+a);
		};
		love.lambda(5);
		
		love =a ->System.out.println("i like lambda -->"+a);//只有一行代码，花括号也省略
		love.lambda(0);
		
	}
}
interface ILove{
	void lambda(int a);
}
//外部类
class Love implements ILove{

	@Override
	public void lambda(int a) {
		System.out.println("i like lambda -->"+a);
	}
	
}

LambdaTest03.java

package com.sxt.thread;
/**
 * lambda推导 +参数+返回值
 *
 */
public class LambdaTest03 {
	
	public static void main(String[] args) {
		IInterest interest = (int a,int c)-> {
			System.out.println("i like lambda -->"+(a+c));
			return a+c;
		};
		interest.lambda(100,200);
		
		interest = (a,c)-> {//去掉类型，多个参数括号不能省略
			System.out.println("i like lambda -->"+(a+c));
			return a+c;
		};
		interest.lambda(200,200);
		
		interest = (a,c)-> {//假设只有一行代码
			return a+c;
		};
		interest = (a,c)-> a+c;//那么可以省掉
		
		interest = (a,c)-> 100;//相当于返回值是100
		
		System.out.println(interest.lambda(10, 20));
	}
}
interface IInterest{
	int lambda(int a,int b);
}
//外部类
class Interest implements IInterest{

	@Override
	public int lambda(int a,int c) {
		System.out.println("i like lambda -->"+(a+c));
		return a+c;
	}
	
}

LambdaTest04.java

package com.sxt.thread;
/**
 * lambda推导
 *
 */
public class LambdaTest04 {
	
	public static void main(String[] args) {
		new Thread(()->{
			for(int i=0;i<100;i++) {
				System.out.println("一边学习lambda");
			}
		}) .start();
		
		new Thread(()->	System.out.println("一边学习奔溃")) .start();
	}
}

11.3线程状态

11.3.1 线程状态

在这里插入图片描述

入选
安排入场
带球奔跑
摔倒了起来后不是马上就去带球奔跑，而是从进场状态开始
替换下场死亡状态后不能再重新开始

new 线程有了自己的工作空间，一个工作空间针对一个线程
start就绪状态具备了运行条件，还没有分配到CPU
（有四种方法可以进入就绪状态1start()2解除3yield()中断一下4jvm切换）
运行状态系统选定才能获得CPU 只有从就绪到这里
阻塞
（有四种方法可以进入阻塞状态1sleep()2wait()3join()插队4read()write()）
死亡 1正常终止2线程被强制终止stop() destory()
在这里插入图片描述

一个线程对象在它的生命周期内，需要经历5个状态。
▪ 新生状态(New)
用new关键字建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态。
▪ 就绪状态(Runnable)
处于就绪状态的线程已经具备了运行条件，但是还没有被分配到CPU，处于“线程就绪队列”，等待系统为其分配CPU。就绪状态并不是执行状态，当系统选定一个等待执行的Thread对象后，它就会进入执行状态。一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。有4中原因会导致线程进入就绪状态：
1.新建线程：调用**start()方法，进入就绪状态;
2.阻塞线程：阻塞解除，进入就绪状态;
3. 运行线程：调用yield()方法，直接进入就绪状态;
4. 运行线程：JVM将CPU资源从本线程切换到其他线程。
▪ 运行状态(Running)
在运行状态的线程执行自己run方法中的代码，直到调用其他方法而终止或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束，就会被系统给换下来回到就绪状态。也可能由于某些“导致阻塞的事件”而进入阻塞状态。
▪ 阻塞状态(Blocked)
阻塞指的是暂停一个线程的执行以等待某个条件发生(如某资源就绪)。有4种原因会导致阻塞：
1.执行sleep(int millsecond)方法，使当前线程休眠，进入阻塞状态。当指定的时间到了后，线程进入就绪状态。
2.执行wait()方法，使当前线程进入阻塞状态。当使用nofity()**方法唤醒这个线程后，它进入就绪状态。
3.线程运行时，某个操作进入阻塞状态，比如执行IO流操作(**read()/write()**方法本身就是阻塞的方法)。只有当引起该操作阻塞的原因消失后，线程进入就绪状态。
4. **join()线程联合: 当某个线程等待另一个线程执行结束后，才能继续执行时，使用join()方法。
▪ 死亡状态(Terminated)
死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个。一个是正常运行的线程完成了它run()方法内的全部工作; 另一个是线程被强制终止，如通过执行stop()或destroy()**方法来终止一个线程(注：stop()/destroy()方法已经被JDK废弃，不推荐使用)。
当一个线程进入死亡状态以后，就不能再回到其它状态了。

11.3.2 终止线程的典型方式

在这里插入图片描述
study线程，用方法来控制标识来停止

终止线程我们一般不使用JDK提供的stop()/destroy()方法(它们本身也被JDK废弃了)。通常的做法是提供一个boolean型的终止变量，当这个变量置为false，则终止线程的运行。

【示例11-3】终止线程的典型方法(重要)

public class TestThreadCiycle implements Runnable {
    String name;
    boolean live = true;// 标记变量，表示线程是否可中止；
    public TestThreadCiycle(String name) {
        super();
        this.name = name;
    }
    public void run() {
        int i = 0;
        //当live的值是true时，继续线程体；false则结束循环，继而终止线程体；
        while (live) {
            System.out.println(name + (i++));
        }
    }
    public void terminate() {
        live = false;
    }
 
    public static void main(String[] args) {
        TestThreadCiycle ttc = new TestThreadCiycle("线程A:");
        Thread t1 = new Thread(ttc);// 新生状态
        t1.start();// 就绪状态
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程" + i);
        }
        ttc.terminate();
        System.out.println("ttc stop!");
    }
}

执行结果如图11-5所示：
在这里插入图片描述

11.3.3 暂停线程执行sleep/礼让yield

在这里插入图片描述
5.阻塞

这个休息的特点是抱着锁睡觉，站在马路中间谁都过不去

例2：龟兔赛跑 sleep()模拟休息
在这里插入图片描述

sleep()方法与对象没关系，谁执行这个线程体，谁就去执行sleep()操作

例3：实现倒计时
在这里插入图片描述

每隔一秒来一次

例4：
在这里插入图片描述
死循环不停

10s就停了

礼让yield()
在这里插入图片描述
可能礼让成功，也可能又重回来调用自己了

例6：用lamda
在这里插入图片描述

有时候礼让成功，有时候礼让不成功

暂停线程执行常用的方法有sleep()和yield()方法，这两个方法的区别是：
1.sleep()方法：可以让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状态。
2.yield()方法：可以让正在运行的线程直接进入就绪状态，让出CPU的使用权。

【示例11-4】暂停线程的方法-sleep()

public class TestThreadState {
    public static void main(String[] args) {
        StateThread thread1 = new StateThread();
        thread1.start();
        StateThread thread2 = new StateThread();
        thread2.start();
    }
}
//使用继承方式实现多线程
class StateThread extends Thread {
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName() + ":" + i);
            try {
                Thread.sleep(2000);//调用线程的sleep()方法；
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行结果如图11-6所示(注：以下图示只是部分结果，运行时可以感受到每条结果输出之前的延迟，是Thread.sleep(2000)语句在起作用)：
在这里插入图片描述
【示例11-5】暂停线程的方法-yield()

public class TestThreadState {
    public static void main(String[] args) {
        StateThread thread1 = new StateThread();
        thread1.start();
        StateThread thread2 = new StateThread();
        thread2.start();
    }
}
//使用继承方式实现多线程
class StateThread extends Thread {
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName() + ":" + i);
            Thread.yield();//调用线程的yield()方法；
        }
    }
}

执行结果如图11-7所示(注：以下图示只是部分结果，可以引起线程切换，但运行时没有明显延迟)：
在这里插入图片描述

11.3.4 线程的联合join()

在这里插入图片描述
插队线程，合并线程。一个车插到别的车前面，别的车就得等插队车走后才能走，并且别的车进入阻塞状态。

例子：
在这里插入图片描述

这样是错误的
因为线程启动后各走各的，不能等到烟回来

儿子线程执行完，老爸线程才能执行

join()写在谁的run方法体中就阻塞谁，谁去调用join()谁就去插队。

线程A在运行期间，可以调用线程B的join()方法，让线程B和线程A联合。这样，线程A就必须等待线程B执行完毕后，才能继续执行。如下面示例中，“爸爸线程”要抽烟，于是联合了“儿子线程”去买烟，必须等待“儿子线程”买烟完毕，“爸爸线程”才能继续抽烟。

【示例11-6】线程的联合-join()

public class TestThreadState {
    public static void main(String[] args) {
        System.out.println("爸爸和儿子买烟故事");
        Thread father = new Thread(new FatherThread());
        father.start();
    }
}
 
class FatherThread implements Runnable {
    public void run() {
        System.out.println("爸爸想抽烟，发现烟抽完了");
        System.out.println("爸爸让儿子去买包红塔山");
        Thread son = new Thread(new SonThread());
        son.start();
        System.out.println("爸爸等儿子买烟回来");
        try {
            son.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("爸爸出门去找儿子跑哪去了");
            // 结束JVM。如果是0则表示正常结束；如果是非0则表示非正常结束
            System.exit(1);
        }
        System.out.println("爸爸高兴的接过烟开始抽，并把零钱给了儿子");
    }
}
 
class SonThread implements Runnable {
    public void run() {
        System.out.println("儿子出门去买烟");
        System.out.println("儿子买烟需要10分钟");
        try {
            for (int i = 1; i <= 10; i++) {
                System.out.println("第" + i + "分钟");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("儿子买烟回来了");
    }
}

执行结果如图11-8所示：
在这里插入图片描述

深度观察状态

在这里插入图片描述
进入就绪状态1.start()2.阻塞解除3.yield()4JVM
进入运行状态是CPU控制的
阻塞1.sleep()2.wait()
死亡terminate

11.4线程优先级

在这里插入图片描述

11.4.1 获取线程基本信息的方法

在这里插入图片描述

【示例11-7】线程的常用方法一

public class TestThread {
    public static void main(String[] argc) throws Exception {
        Runnable r = new MyThread();
        Thread t = new Thread(r, "Name test");//定义线程对象，并传入参数；
        t.start();//启动线程；
        System.out.println("name is: " + t.getName());//输出线程名称；
        Thread.currentThread().sleep(5000);//线程暂停5分钟；
        System.out.println(t.isAlive());//判断线程还在运行吗？
        System.out.println("over!");
    }
}
class MyThread implements Runnable {
    //线程体；
    public void run() {
        for (int i = 0; i < 10; i++)
            System.out.println(i);
    }
}

执行结果如图11-9所示：
在这里插入图片描述

11.4.2 线程的优先级

1.处于就绪状态的线程，会进入“就绪队列”等待JVM来挑选。
2.线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级是5。
3.使用下列方法获得或设置线程对象的优先级。
int getPriority();
void setPriority(int newPriority);
注意：优先级低只是意味着获得调度的概率低。并不是绝对先调用优先级高的线程后调用优先级低的线程。

【示例11-8】线程的常用方法二

public class TestThread {
	public static void main(String[] args) {
		Thread t1 = new Thread(new MyThread(), "t1");
		Thread t2 = new Thread(new MyThread(), "t2");
		t1.setPriority(1);
		t2.setPriority(10);
		t1.start();
		t2.start();
	}
}
class MyThread extends Thread {
	public void run() {
		for (int i = 0; i < 10; i++) {
		    System.out.println(Thread.currentThread().getName() + ": " + i);
		}
	}
}

执行结果如图11-10所示：
在这里插入图片描述

守护线程

在这里插入图片描述

11.5 线程同步

三大经典案例

synchronized
在这里插入图片描述
UnsafeTest01.java

package com.sxt.syn;
/**
 * 线程不安全: 数据有负数、相同
 *
 */
public class UnsafeTest01 {

	public static void main(String[] args) {
		//一份资源
		UnsafeWeb12306 web =new UnsafeWeb12306();
		//多个代理
		new Thread(web,"码畜").start();
		new Thread(web,"码农").start();
		new Thread(web,"码蟥").start();;
	}

}

class UnsafeWeb12306 implements Runnable{
	//票数
	private int ticketNums =10;
	private boolean flag = true;
	@Override
	public void run() {
		while(flag) {
			test();
		}
	}	
	public void test() {
		if(ticketNums<0) {
			flag = false;
			return ;
		}
		//模拟延时
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);
	}
}

在这里插入图片描述
多个代理同时去访问

有负数的情况、有相同的情况
分析：负数：临界值没有控制相同的值：拷贝10的时候已经都拿到自己的工作台
Account.java

package com.sxt.syn;
class Account{
	int money; //金额
	String name; //名称
	public Account(int money, String name) {
		this.money = money;
		this.name = name;
	}
	
}

UnsafeTest02.java

package com.sxt.syn;
/**
 * 线程不安全：取钱
 */
public class UnsafeTest02 {
	public static void main(String[] args) {
		//账户
		Account account =new Account(100,"结婚礼金");
		Drawing you = new Drawing(account,80,"可悲的你");
		Drawing wife = new Drawing(account,90,"happy的她");
		you.start();
		wife.start();
	}
}
//模拟取款
class Drawing extends Thread{
	Account account ; //取钱的账户
	int drawingMoney ;//取的钱数
	int packetTotal ; //口袋的总数	
	
	public Drawing(Account account, int drawingMoney,String name) {
		super(name);
		this.account = account;
		this.drawingMoney = drawingMoney;
	}

	@Override
	public void run() {
		if(account.money -drawingMoney<0) {
			return;
		}
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		account.money -=drawingMoney;
		packetTotal +=drawingMoney;
		System.out.println(this.getName()+"-->账户余额为:"+account.money);
		System.out.println(this.getName()+"-->口袋的钱为:"+packetTotal);
	}
	
}

在这里插入图片描述
UnsafeTest03。java

package com.sxt.syn;

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

/**
 * 线程不安全：操作容器
 */
public class UnsafeTest03 {
	public static void main(String[] args) throws InterruptedException {
		List<String> list = new ArrayList<String>();
		for(int i=0;i<10000;i++) {
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}) .start();
		}
		System.out.println(list.size());
	}
}

在这里插入图片描述

同步的两个条件：队列与锁

保证线程安全：排队，根据算法决定谁先用谁后用。怎么知道谁在用，卡，锁。
每个对象都有一个排它锁
在这里插入图片描述

synchronized方法

目标对，效率高
SynTest01.java

package com.sxt.syn;
/**
 * 线程安全: 在并发时保证数据的正确性、效率尽可能高
 * synchronized
 * 1、同步方法
 * 2、同步块
 */
public class SynTest01 {

	public static void main(String[] args) {
		//一份资源
		SafeWeb12306 web =new SafeWeb12306();
		//多个代理
		new Thread(web,"码畜").start();
		new Thread(web,"码农").start();
		new Thread(web,"码蟥").start();;
	}

}

class SafeWeb12306 implements Runnable{
	//票数
	private int ticketNums =10;
	private boolean flag = true;
	@Override
	public void run() {
		while(flag) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			test();
		}
	}	
	//线程安全  同步
	public synchronized void test() {//B线程进来了，此时
		if(ticketNums<=0) {
			flag = false;
			return ;
		}
		//模拟延时
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);
	}
}

一个一个蹦出来的，有队列
synchronized操作了什么，锁了对象的资源、而不是锁方法
SynTest02.java

package com.sxt.syn;
/**
 * 线程安全: 在并发时保证数据的正确性、效率尽可能高
 * synchronized
 * 1、同步方法
 * 2、同步块 
 */
public class SynTest02 {
	public static void main(String[] args) {		
		//账户
		Account account =new Account(100,"结婚礼金");
		SafeDrawing you = new SafeDrawing(account,80,"可悲的你");
		SafeDrawing wife = new SafeDrawing(account,90,"happy的她");
		you.start();
		wife.start();
	}
} 
 


//模拟取款
class SafeDrawing extends Thread{
	Account account ; //取钱的账户
	int drawingMoney ;//取的钱数
	int packetTotal ; //口袋的总数	
	
	public SafeDrawing(Account account, int drawingMoney,String name) {
		super(name);
		this.account = account;
		this.drawingMoney = drawingMoney;
	}

	@Override
	public void run() {
		test();
	}
	//目标不对锁定失败  这里不是锁this 应该锁定 account
	public synchronized void test() {
		if(account.money -drawingMoney<0) {
			return; 
		}
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		account.money -=drawingMoney;
		packetTotal +=drawingMoney;
		System.out.println(this.getName()+"-->账户余额为:"+account.money);
		System.out.println(this.getName()+"-->口袋的钱为:"+packetTotal);
	}
}

synchronized锁的是账户而不是提款机
以上代码失败，执行结果还是有负数

synchronized块

在这里插入图片描述
方法里面的块：局部块
构造块：对象的信息
静态块：类的信息
同步块：
SynBlockTest01.java

package com.sxt.syn;
/**
 * 线程安全: 在并发时保证数据的正确性、效率尽可能高
 * synchronized
 * 1、同步方法
 * 2、同步块 ,目标更明确
 */
public class SynBlockTest01 {
	public static void main(String[] args) {		
		//账户
		Account account =new Account(1000,"结婚礼金");
		SynDrawing you = new SynDrawing(account,80,"可悲的你");
		SynDrawing wife = new SynDrawing(account,90,"happy的她");
		you.start();
		wife.start();
	}
} 
 //模拟取款 线程安全
class SynDrawing extends Thread{
	Account account ; //取钱的账户
	int drawingMoney ;//取的钱数
	int packetTotal ; //口袋的总数	
	
	public SynDrawing(Account account, int drawingMoney,String name) {
		super(name);
		this.account = account;
		this.drawingMoney = drawingMoney;
	}

	@Override
	public void run() {
		test() ;
	}
	//目标锁定account
	public  void test() {
		//提高性能
		if(account.money<=0) {//都没有房间了，还要问有没有房间的钥匙么，就不需要了
			return ;
		}
		//同步块
		synchronized(account) {
			if(account.money -drawingMoney<0) {
				return; 
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			account.money -=drawingMoney;
			packetTotal +=drawingMoney;
			System.out.println(this.getName()+"-->账户余额为:"+account.money);
			System.out.println(this.getName()+"-->口袋的钱为:"+packetTotal);
		}
	}
}

account对象看有没有锁，有的话就阻塞
什么时候释放：所有操作都执行完
在这里插入图片描述
把金额调大了，只要金额够，你就能拿到

SynBlockTest02.java

package com.sxt.syn;

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

/**
 * 线程安全：操作容器
 */
public class SynBlockTest02 {
	public static void main(String[] args) throws InterruptedException {
		List<String> list = new ArrayList<String>();
		for(int i=0;i<10000;i++) {
			new Thread(()->{
				//同步块
				synchronized(list) {//添加的时候保证list是拿到锁的
					list.add(Thread.currentThread().getName());
				}
			}) .start();
		}
		Thread.sleep(10000);
		System.out.println(list.size());
	}
}

同步性能分析

SynBlockTest03.java

package com.sxt.syn;
/**
 * 线程安全: 在并发时保证数据的正确性、效率尽可能高
 * synchronized
 * 1、同步方法
 * 2、同步块
 */
public class SynBlockTest03 {

	public static void main(String[] args) {
		//一份资源
		SynWeb12306 web =new SynWeb12306();
		//多个代理
		new Thread(web,"码畜").start();
		new Thread(web,"码农").start();
		new Thread(web,"码蟥").start();;
	}

}

class SynWeb12306 implements Runnable{
	//票数
	private int ticketNums =10;
	private boolean flag = true;
	@Override
	public void run() {
		while(flag) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			test5();
		}
	}	
	//线程安全:尽可能锁定合理的范围(不是指代码 指数据的完整性)
	//double checking
	public  void test5() {
		if(ticketNums<=0) {//考虑的是没有票的情况
			flag = false;
			return ;
		}
		synchronized(this) {			
			if(ticketNums<=0) {//考虑最后的1张票
				flag = false;
				return ;
			}
			//模拟延时
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);
		}
	}
	//线程不安全  范围太小锁不住
	public  void test4() {
		synchronized(this) {
				if(ticketNums<=0) {
					flag = false;
					return ;
				}
		}
			//模拟延时
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);
		
	}
	//线程不安全  ticketNums对象在变
	public  void test3() {
		synchronized((Integer)ticketNums) {//没锁对
			if(ticketNums<=0) {
				flag = false;
				return ;
			}
			//模拟延时
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);
		}
	}
	//线程安全 范围太大 -->效率低下
	public  void test2() {
		synchronized(this) {//ticketNums、flag两
			if(ticketNums<=0) {
				flag = false;
				return ;
			}
			//模拟延时
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);
		}
	}
	
	
	//线程安全  同步
	public synchronized void test1() {
		if(ticketNums<=0) {
			flag = false;
			return ;
		}
		//模拟延时
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"-->"+ticketNums--);
	}
}

快乐影院

HappyCinema.java

package com.sxt.syn;
/**
 * 快乐影院
 */
public class HappyCinema {

	public static void main(String[] args) {
		Cinema c = new Cinema(2,"happy sxt");
		new Thread(new Customer(c,2),"老高").start();
		new Thread(new Customer(c,1),"老裴").start();
	}

}
//顾客
class Customer implements Runnable{
	Cinema cinema;//去哪里看电影
	int seats;	//几个位置
	public Customer(Cinema cinema, int seats) {
		this.cinema = cinema;
		this.seats = seats;
	}

	@Override
	public void run() {
		synchronized(cinema) {//锁影院
			boolean flag = cinema.bookTickets(seats);
			if(flag) {
				System.out.println("出票成功"+Thread.currentThread().getName()+"-<位置为:"+seats);
			}else {
				System.out.println("出票失败"+Thread.currentThread().getName()+"-<位置不够");			
			}
		}
	}
	
}

//影院
class Cinema{
	int available; //可用的位置
	String name; //名称
	public Cinema(int available, String name) {
		this.available = available;
		this.name = name;
	}
	
	//购票
	public boolean bookTickets(int seats) {
		System.out.println("可用位置为:"+available);
		if(seats>available) {
			return false;
		}
		available -=seats;
		return true;
	}
}

票数20没加同步代码块之前
在这里插入图片描述
票数20，加了之后

票数2，加了之后

还要加上选位置功能，加上容器
HappyCinema2java

package com.sxt.syn;

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

/**
 * 快乐影院
 * 
 * @author 裴新 QQ:3401997271
 *
 */
public class HappyCinema2 {

	public static void main(String[] args) {
		//可用位置
		List<Integer> available =new ArrayList<Integer>();
		available.add(1);
		available.add(2);
		available.add(3);
		available.add(6);
		available.add(7);
		
		//顾客需要的位置
		List<Integer> seats1 =new ArrayList<Integer>();
		seats1.add(1);
		seats1.add(2);
		List<Integer> seats2 =new ArrayList<Integer>();
		seats2.add(4);
		seats2.add(5);
		seats2.add(6);
		
		
		SxtCinema c = new SxtCinema(available,"happy sxt");
		new Thread(new HappyCustomer(c,seats1),"老高").start();
		new Thread(new HappyCustomer(c,seats2),"老裴").start();
	}

}
//顾客
class HappyCustomer implements Runnable{
	SxtCinema cinema;
	List<Integer> seats;	
	public HappyCustomer(SxtCinema cinema, List<Integer> seats) {
		this.cinema = cinema;
		this.seats = seats;
	}

	@Override
	public void run() {
		synchronized(cinema) {
			boolean flag = cinema.bookTickets(seats);
			if(flag) {
				System.out.println("出票成功"+Thread.currentThread().getName()+"-<位置为:"+seats);
			}else {
				System.out.println("出票失败"+Thread.currentThread().getName()+"-<位置不够");			
			}
		}
	}
	
}

//影院
class SxtCinema{
	List<Integer> available; //可用的位置
	String name; //名称
	public SxtCinema(List<Integer> available, String name) {
		this.available = available;
		this.name = name;
	}
	
	//购票
	public boolean bookTickets(List<Integer> seats) {//传具体的位置
		System.out.println("欢迎光临"+this.name+"，当前可用位置为:"+available);
		List<Integer> copy = new ArrayList<Integer>();
		copy.addAll(available);
		
		//相减
		copy.removeAll(seats);
		//判断大小
		if(available.size()-copy.size() !=seats.size()) {
			return false;
		}
		//成功
		available = copy;
		return true;
	}
}

在这里插入图片描述

快乐火车票

以上都是使用同步块，以下使用同步方法
Happy12306.java

package com.sxt.syn;
/**
 * 快乐火车票
 * 
 * @author 裴新 QQ:3401997271
 *
 */
public class Happy12306 {

	public static void main(String[] args) {
		Web12306 c = new Web12306(4,"happy sxt");
		new  Passenger(c,"老高",2).start();
		new  Passenger(c,"老裴",1).start();
	}

}
//顾客
class Passenger extends  Thread{//Passenger 是代理
	int seats;		
	public Passenger(Runnable target,String name,int seats) {
		super(target,name);
		this.seats = seats;
	}
	
}
//火车票网
class Web12306 implements Runnable{
	int available; //可用的位置
	String name; //名称
	public Web12306(int available, String name) {
		this.available = available;
		this.name = name;
	}
	
	public void run() {
			Passenger p = (Passenger)Thread.currentThread();//当前线程是顾客
			boolean flag = this.bookTickets(p.seats);
			if(flag) {
				System.out.println("出票成功"+Thread.currentThread().getName()+"-<位置为:"+p.seats);
			}else {
				System.out.println("出票失败"+Thread.currentThread().getName()+"-<位置不够");			
			}
	}
	//购票
	public synchronized boolean bookTickets(int seats) {
		System.out.println("可用位置为:"+available);
		if(seats>available) {
			return false;
		}
		available -=seats;
		return true;
	}
}

在这里插入图片描述

要使用同步方法只能写在12306里面，写完之后怎么和乘客打交道
乘客我们让他继承Thread，直接作为代理，子类中加线程变量，把父类的构造器延续下来，同时加入了自己的线程变量

用的时候我们要知道是哪个

并发容器

锁定了list
list有对应的并发容器，自己进行锁定，就不需要我们来
SynContainer.java

package com.sxt.syn;

import java.util.ArrayList;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.List;

/**
 * 线程安全：操作并发容器
 */
public class SynContainer {
	public static void main(String[] args) throws InterruptedException {
		CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
		for(int i=0;i<10000;i++) {
			new Thread(()->{
				list.add(Thread.currentThread().getName());
			}) .start();
		}
		Thread.sleep(10000);
		System.out.println(list.size());
	}
}

死锁_产生与解决

在这里插入图片描述
DeadLock.java

package com.sxt.syn;
/**
 * 死锁: 过多的同步可能造成相互不释放资源
 * 从而相互等待，一般发生于同步中持有多个对象的锁
 * 
 * 避免: 不要在同一个代码块中，同时持有多个对象的锁
 * 
 */
public class DeadLock {

	public static void main(String[] args) {
		Markup g1 = new Markup(1,"张柏芝");
		Markup g2 = new Markup(0,"王菲");
		g1.start();
		g2.start();
	}

}
//口红
class Lipstick{
	
}
//镜子
class Mirror{
	
}
//化妆
class Markup extends Thread{ 
	static Lipstick lipstick = new Lipstick();//来一个口红一面镜子
	static Mirror mirror = new Mirror();
	//选择
	int choice;
	//名字
	String girl;
	public Markup(int choice,String girl) {
		this.choice = choice;
		this.girl = girl;
	}

	@Override
	public void run() {
		//化妆
		markup();
	}
	//相互持有对方的对象锁-->可能造成死锁
	private void markup() {
		if(choice==0) {
			synchronized(lipstick) { //获得口红的锁
				System.out.println(this.girl+"涂口红");
				//1秒后想拥有镜子的锁
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				/*
				synchronized(mirror) {
					System.out.println(this.girl+"照镜子");
				}*/			
			}
			synchronized(mirror) {
				System.out.println(this.girl+"照镜子");
			}		
		}else {
				synchronized(mirror) { //获得镜子的锁
					System.out.println(this.girl+"照镜子");
					//2秒后想拥有口红的锁
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					/*
					synchronized(lipstick) {
						System.out.println(this.girl+"涂口红");
					}	*/
					
			}
				synchronized(lipstick) {
					System.out.println(this.girl+"涂口红");
				}
		}
	}
}

在这里插入图片描述
注释的那种情况：造成了死锁
解决方式：后一种往外挪一下，不要锁套锁

11.5.1 什么是线程同步

▪ 同步问题的提出
现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题。比如：教室里，只有一台电脑，多个人都想使用。天然的解决办法就是，在电脑旁边，大家排队。前一人使用完后，后一人再使用。
▪ 线程同步的概念
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候，我们就需要用到“线程同步”。线程同步其实就是一种等待机制，这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。

【示例11-9】多线程操作同一个对象(未使用线程同步)

public class TestSync {
public static void main(String[] args) {
Account a1 = new Account(100, “高”);
Drawing draw1 = new Drawing(80, a1);// 定义取钱线程对象；
Drawing draw2 = new Drawing(80, a1);// 定义取钱线程对象；
draw1.start(); // 你取钱
draw2.start(); // 你老婆取钱
}
}
/*

简单表示银行账户
*/
class Account {
int money;
String aname;

public Account(int money, String aname) {
super();
this.money = money;
this.aname = aname;
}
}
/**
模拟提款操作
*/
class Drawing extends Thread {
int drawingNum; // 取多少钱
Account account; // 要取钱的账户
int expenseTotal; // 总共取的钱数

public Drawing(int drawingNum, Account account) {
super();
this.drawingNum = drawingNum;
this.account = account;
}

@Override
public void run() {
if (account.money - drawingNum < 0) {
return;
}
try {
Thread.sleep(1000); // 判断完后阻塞。其他线程开始运行。
} catch (InterruptedException e) {
e.printStackTrace();
}
account.money -= drawingNum;
expenseTotal += drawingNum;
System.out.println(this.getName() + “–账户余额：” + account.money);
System.out.println(this.getName() + “–总共取了：” + expenseTotal);
}
}
执行结果如图11-11所示：

没有线程同步机制，两个线程同时操作同一个账户对象，竟然从只有100元的账户，轻松取出80*2=160元，账户余额竟然成为了-60。这么大的问题，显然银行不会答应的。

11.5.2 实现线程同步

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问造成的这种问题。
由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized 方法和 synchronized 块。

▪ synchronized 方法
通过在方法声明中加入 synchronized关键字来声明，语法如下：
public synchronized void accessVal(int newVal);
synchronized 方法控制对“对象的类成员变量”的访问：每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

▪ synchronized块
synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率。
Java 为我们提供了更好的解决办法，那就是 synchronized 块。块可以让我们精确地控制到具体的“成员变量”，缩小同步的范围，提高效率。
synchronized 块：通过 synchronized关键字来声明synchronized 块，语法如下：
synchronized(syncObject)
　 {
　　 //允许访问控制的代码
　 }
【示例11-10】多线程操作同一个对象(使用线程同步)

public class TestSync {
public static void main(String[] args) {
Account a1 = new Account(100, “高”);
Drawing draw1 = new Drawing(80, a1);
Drawing draw2 = new Drawing(80, a1);
draw1.start(); // 你取钱
draw2.start(); // 你老婆取钱
}
}
/*

简单表示银行账户
/
class Account {
int money;
String aname;
public Account(int money, String aname) {
super();
this.money = money;
this.aname = aname;
}
}
/*
模拟提款操作
@author Administrator

*/
class Drawing extends Thread {
int drawingNum; // 取多少钱
Account account; // 要取钱的账户
int expenseTotal; // 总共取的钱数

public Drawing(int drawingNum, Account account) {
    super();
    this.drawingNum = drawingNum;
    this.account = account;
}

@Override
public void run() {
    draw();
}

void draw() {
    synchronized (account) {
        if (account.money - drawingNum < 0) {
            System.out.println(this.getName() + "取款，余额不足！");
            return;
        }
        try {
            Thread.sleep(1000); // 判断完后阻塞。其他线程开始运行。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money -= drawingNum;
        expenseTotal += drawingNum;
    }
    System.out.println(this.getName() + "--账户余额：" + account.money);
    System.out.println(this.getName() + "--总共取了：" + expenseTotal);
}

}
执行结果如图11-12和图11-13所示：
在这里插入图片描述
“synchronized (account)” 意味着线程需要获得account对象的“锁”才有资格运行同步块中的代码。 Account对象的“锁”也称为“互斥锁”，在同一时刻只能被一个线程使用。A线程拥有锁，则可以调用“同步块”中的代码;B线程没有锁，则进入account对象的“锁池队列”等待，直到A线程使用完毕释放了account对象的锁，B线程得到锁才可以开始调用“同步块”中的代码。

11.5.3 死锁及解决方案

死锁的概念
“死锁”指的是：
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。
因此，某一个同步块需要同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。下面案例中，“化妆线程”需要同时拥有“镜子对象”、“口红对象”才能运行同步块。那么，实际运行时，“小丫的化妆线程”拥有了“镜子对象”，“大丫的化妆线程”拥有了“口红对象”，都在互相等待对方释放资源，才能化妆。这样，两个线程就形成了互相等待，无法继续运行的“死锁状态”。

【示例11-11】死锁问题演示

class Lipstick {//口红类
 
}
class Mirror {//镜子类
 
}
class Makeup extends Thread {//化妆类继承了Thread类
    int flag;
    String girl;
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
        doMakeup();
    }
 
    void doMakeup() {
        if (flag == 0) {
            synchronized (lipstick) {//需要得到口红的“锁”；
                System.out.println(girl + "拿着口红！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
 
                synchronized (mirror) {//需要得到镜子的“锁”；
                    System.out.println(girl + "拿着镜子！");
                }
 
            }
        } else {
            synchronized (mirror) {
                System.out.println(girl + "拿着镜子！");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipstick) {
                    System.out.println(girl + "拿着口红！");
                }
            }
        }
    }
 
}
 
public class TestDeadLock {
    public static void main(String[] args) {
        Makeup m1 = new Makeup();//大丫的化妆线程；
        m1.girl = "大丫";
        m1.flag = 0;
        Makeup m2 = new Makeup();//小丫的化妆线程；
        m2.girl = "小丫";
        m2.flag = 1;
        m1.start();
        m2.start();
    }
}

执行结果如图11-14所示(两线程都在等对方的资源，都处于停滞状态)：
在这里插入图片描述
死锁的解决方法
死锁是由于“同步块需要同时持有多个对象锁造成”的，要解决这个问题，思路很简单，就是：同一个代码块，不要同时持有两个对象锁。如上面的死锁案例，修改成示例10-11所示。

【示例11-12】死锁问题的解决

class Lipstick {//口红类
 
}
class Mirror {//镜子类
 
}
class Makeup extends Thread {//化妆类继承了Thread类
    int flag;
    String girl;
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
 
    @Override
    public void run() {
        // TODO Auto-generated method stub
        doMakeup();
    }
 
    void doMakeup() {
        if (flag == 0) {
            synchronized (lipstick) {
                System.out.println(girl + "拿着口红！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
 
            }
            synchronized (mirror) {
                System.out.println(girl + "拿着镜子！");
            }
        } else {
            synchronized (mirror) {
                System.out.println(girl + "拿着镜子！");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (lipstick) {
                System.out.println(girl + "拿着口红！");
            }
        }
    }
}
 
public class TestDeadLock {
    public static void main(String[] args) {
        Makeup m1 = new Makeup();// 大丫的化妆线程；
        m1.girl = "大丫";
        m1.flag = 0;
        Makeup m2 = new Makeup();// 小丫的化妆线程；
        m2.girl = "小丫";
        m2.flag = 1;
        m1.start();
        m2.start();
    }
}

执行结果如图11-15和图11-16所示(两线程都可以得到需要的资源，程序正常运行结束)：
在这里插入图片描述

11.6 线程并发协作(生产者/消费者模式)

生产者/消费者模式

线程与线程之间如何通信？
设计模式是指：类与类之间的组织方式
并发的模式：生产者消费者模型
阿里：应用层服务层数据层
服务层与应用层之间进行解耦
服务层：用户中心商户中心交易中心
应用层：用户界面
消息队列
在这里插入图片描述

管程法

在这里插入图片描述
生产者：多线程
缓冲区：容器并发
存：不够
取：空
消费者：多线程
比如：我们要操作馒头

CoTest01.java

package com.sxt.cooperation;
/**
 * 协作模型:生产者消费者实现方式一:管程法
 * 借助缓冲区
 */
public class CoTest01 {
	public static void main(String[] args) {
		SynContainer container = new SynContainer();
		new Productor(container).start();
		new Consumer(container).start();
	}
}
//生产者
class Productor extends Thread{
	SynContainer container  ;	
	public Productor(SynContainer container) {
		this.container = container;
	}

	public void run() {
		//生产
		for(int i=0;i<100;i++) {
			System.out.println("生产-->"+i+"个馒头");
			container.push(new Steamedbun(i) );
		}
	}
}
//消费者
class Consumer extends Thread{
	SynContainer container  ;	
	public Consumer(SynContainer container) {
		this.container = container;
	}
	public void run() {
		//消费
		for(int i=0;i<100;i++) {
			System.out.println("消费-->"+container.pop().id+"个馒头");
		}
	}
}
//缓冲区
class SynContainer{
	Steamedbun[] buns = new Steamedbun[10]; //存储容器
	int count = 0; //计数器
	//存储 生产
	public synchronized void push(Steamedbun bun) {
		//何时能生产  容器存在空间
		//不能生产 只有等待
		if(count == buns.length) {
			try {
				this.wait(); //线程阻塞  消费者通知生产解除
			} catch (InterruptedException e) {
			}
		}
		//存在空间 可以生产
		buns[count] = bun;
		count++;
		//存在数据了，可以通知消费了
		this.notifyAll();
	}
	//获取 消费
	public synchronized Steamedbun pop() {
		//何时消费 容器中是否存在数据
		//没有数据 只有等待
		if(count == 0) {
			try {
				this.wait(); //线程阻塞  生产者通知消费解除
			} catch (InterruptedException e) {
			}
		}
		//存在数据可以消费
		count --;//从最后一个拿
		Steamedbun bun = buns[count] ;		
		this.notifyAll(); //存在空间了，可以唤醒对方生产了。所有的阻塞都被唤醒
		return bun;
	}
}
//馒头
class Steamedbun{
	int id;
	public Steamedbun(int id) {
		this.id = id;
	}
	
}

在这里插入图片描述

根据容器进行交流的

信号灯法

CoTest02.java

package com.sxt.cooperation;
/**
 * 协作模型:生产者消费者实现方式二:信号灯法
 * 借助标志位
 */
public class CoTest02 {
	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;
	}

	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;
	}

	public void run() {
		for(int i=0;i<20;i++) {
			tv.watch();
		}
	}
}
//同一个资源 电视
class Tv{
	String voice;
	//信号灯
	//T 表示演员表演 观众等待
	//F 表示观众观看 演员等待
	boolean flag = true;
	
	//表演
	public  synchronized void play(String voice) {
		//演员等待
		if(!flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}		
		//表演
		System.out.println("表演了:"+voice);
		this.voice = voice;
		//唤醒
		this.notifyAll();
		//切换标志
		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;
	}
}

在这里插入图片描述

生产者/消费者模式

多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者/消费者模式”。

Ø 什么是生产者?
生产者指的是负责生产数据的模块(这里模块可能是：方法、对象、线程、进程)。
Ø 什么是消费者?
消费者指的是负责处理数据的模块(这里模块可能是：方法、对象、线程、进程)。
Ø 什么是缓冲区?
消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。
在这里插入图片描述

缓冲区是实现并发的核心，缓冲区的设置有3个好处：
Ø 实现线程的并发协作
有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况;同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离。
Ø 解耦了生产者和消费者
生产者不需要和消费者直接打交道。
Ø 解决忙闲不均，提高效率
生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费;消费者处理数据慢时，生产者仍然可以继续往缓冲区里面放置数据。

【示例11-13】生产者与消费者模式

public class TestProduce {
    public static void main(String[] args) {
        SyncStack sStack = new SyncStack();// 定义缓冲区对象；
        Shengchan sc = new Shengchan(sStack);// 定义生产线程；
        Xiaofei xf = new Xiaofei(sStack);// 定义消费线程；
        sc.start();
        xf.start();
    }
}
 
class Mantou {// 馒头
    int id;
 
    Mantou(int id) {
        this.id = id;
    }
}
 
class SyncStack {// 缓冲区(相当于：馒头筐)
    int index = 0;
    Mantou[] ms = new Mantou[10];
 
    public synchronized void push(Mantou m) {
        while (index == ms.length) {//说明馒头筐满了
            try {
               //wait后，线程会将持有的锁释放，进入阻塞状态；
               //这样其它需要锁的线程就可以获得锁；
                this.wait();
                //这里的含义是执行此方法的线程暂停，进入阻塞状态，
                //等消费者消费了馒头后再生产。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 唤醒在当前对象等待池中等待的第一个线程。
        //notifyAll叫醒所有在当前对象等待池中等待的所有线程。
        this.notify();
        // 如果不唤醒的话。以后这两个线程都会进入等待线程，没有人唤醒。
        ms[index] = m;
        index++;
    }
 
    public synchronized Mantou pop() {
        while (index == 0) {//如果馒头筐是空的；
            try {
                //如果馒头筐是空的，就暂停此消费线程（因为没什么可消费的嘛）。
                this.wait();                //等生产线程生产完再来消费；
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        index--;
        return ms[index];
    }
}
 
class Shengchan extends Thread {// 生产者线程
    SyncStack ss = null;
 
    public Shengchan(SyncStack ss) {
        this.ss = ss;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("生产馒头：" + i);
            Mantou m = new Mantou(i);
            ss.push(m);
        }
    }
}
 
class Xiaofei extends Thread {// 消费者线程；
    SyncStack ss = null;
 
    public Xiaofei(SyncStack ss) {
        this.ss = ss;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            Mantou m = ss.pop();
            System.out.println("消费馒头：" + i);
 
        }
    }
}

执行结果如图11-18所示：
在这里插入图片描述
线程并发协作总结：
线程并发协作(也叫线程通信)，通常用于生产者/消费者模式，情景如下：
1.生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。
2.对于生产者，没有生产产品之前，消费者要进入等待状态。而生产了产品之后，又需要马上通知消费者消费。
3.对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品以供消费。
4.在生产者消费者问题中，仅有synchronized是不够的。
synchronized可阻止并发更新同一个共享资源，实现了同步;
synchronized不能用来实现不同线程之间的消息传递(通信)。
5.那线程是通过哪些方法来进行消息传递(通信)的呢?见如下总结：
在这里插入图片描述
6.以上方法均是java.lang.Object类的方法;
都只能在同步方法或者同步代码块中使用，否则会抛出异常。
老鸟建议
在实际开发中，尤其是“架构设计”中，会大量使用这个模式。对于初学者了解即可，如果晋升到中高级开发人员，这就是必须掌握的内容。

11.7 任务定时调度

通过Timer和Timetask，我们可以实现定时启动某个线程。
java.util.Timer
在这种实现方式中，Timer类作用是类似闹钟的功能，也就是定时或者每隔一定时间触发一次线程。其实，Timer类本身实现的就是一个线程，只是这个线程是用来实现调用其它线程的。

java.util.TimerTask
TimerTask类是一个抽象类，该类实现了Runnable接口，所以该类具备多线程的能力。

在这种实现方式中，通过继承TimerTask使该类获得多线程的能力，将需要多线程执行的代码书写在run方法内部，然后通过Timer类启动线程的执行。

【示例11-14】java.util.Timer的使用

public class TestTimer {
    public static void main(String[] args) {
        Timer t1 = new Timer();//定义计时器；
        MyTask task1 = new MyTask();//定义任务；
        t1.schedule(task1,3000);  //3秒后执行；
        //t1.schedule(task1,5000,1000);//5秒以后每隔1秒执行一次！
        //GregorianCalendar calendar1 = new GregorianCalendar(2010,0,5,14,36,57); 
        //t1.schedule(task1,calendar1.getTime()); //指定时间定时执行； 
    }
}
 
class MyTask extends TimerTask {//自定义线程类继承TimerTask类；
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("任务1:"+i);
        }
    }
}

执行结果如图11-19所示：
在这里插入图片描述
运行以上程序时，可以感觉到在输出之前有明显的延迟(大概就是3秒!)。还有几个方法，我注释掉了，大家自己试试吧!
在实际使用时，一个Timer可以启动任意多个TimerTask实现的线程，但是多个线程之间会存在阻塞。所以如果多个线程之间需要完全独立的话，最好还是一个Timer启动一个TimerTask实现。
老鸟建议
实际开发中，我们可以使用开源框架quanz，更加方便的实现任务定时调度。实际上，quanz底层原理就是我们这里介绍的内容。

高级主题

定时调度

在这里插入图片描述

TimerTest01.java

package com.sxt.others;

import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 任务调度: Timer 和TimerTask类

 */
public class TimerTest01 {

	public static void main(String[] args) {
		Timer timer = new Timer();//就是一个闹钟
		//执行安排
		//timer.schedule(new MyTask(), 1000);  //执行任务一次
		//timer.schedule(new MyTask(), 1000,200); //执行多次  每隔200ms执行1次
		Calendar cal = new GregorianCalendar(2099999,12,31,21,53,54);
		timer.schedule(new MyTask(), cal.getTime(),200); //指定时间
	}

}
//任务类
class  MyTask extends TimerTask{

	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("放空大脑休息一会");
		}
		System.out.println("------end-------");
	}
	
}

quartz

在这里插入图片描述
调度器
除法器
任务
集成到了spring框架中

使用quartz
需要去官网下载，下载好后需要导包。
里面有很多案例。
HelloJob.java

/* 
 * All content copyright Terracotta, Inc., unless otherwise indicated. All rights reserved. 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not 
 * use this file except in compliance with the License. You may obtain a copy 
 * of the License at 
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0 
 *   
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
 * License for the specific language governing permissions and limitations 
 * under the License.
 * 
 */
 
package com.sxt.others;
import java.util.Date;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * 任务
 */
public class HelloJob implements Job {

    public HelloJob() {
    }


    public void execute(JobExecutionContext context)
        throws JobExecutionException {
    	System.out.println("-------start---------");
        System.out.println("Hello World! - " + new Date());
        System.out.println("-------end---------");
    }

}

QuartzTest.java

package com.sxt.others;

import static org.quartz.DateBuilder.evenSecondDateAfterNow;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;
/**
 * quartz学习入门
 */
public class QuartzTest {

  public void run() throws Exception {
    //1、创建 Scheduler的工厂
    SchedulerFactory sf = new StdSchedulerFactory();
    //2、从工厂中获取调度器
    Scheduler sched = sf.getScheduler();  
    // 3、创建JobDetail
    JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();
    // 时间
    Date runTime = evenSecondDateAfterNow();
    // 4、触发条件
    //Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).build();
    Trigger trigger  = newTrigger().withIdentity("trigger1", "group1").startAt(runTime)
            .withSchedule(simpleSchedule().withIntervalInSeconds(5).withRepeatCount(3)).build();
    // 5、注册任务和触发条件
    sched.scheduleJob(job, trigger);
    // 6、启动
    sched.start();


    try {
      // 100秒后停止
      Thread.sleep(100L * 1000L);
    } catch (Exception e) {
    }
    sched.shutdown(true);
  }

  public static void main(String[] args) throws Exception {

    QuartzTest example = new QuartzTest();
    example.run();

  }

}

1秒钟后执行
用的时候直接去拷贝example

happenbefore

在这里插入图片描述

在这里插入图片描述
第一步从内存中获取指令fetch将指令进行解码翻译

第二步从寄存器中拿出对应的值、工作内存，需要拷贝

第三步计算

第四步同步到主存

在这里插入图片描述
看到下一个指令与上一条无关，那么就提前执行了指令重排对我们的指令是有影响的

在这里插入图片描述

HappenBefore.java

package com.sxt.others;
/**
 * 指令重排: 代码执行顺序与预期不一致
 * 目的:提高性能
 */
public class HappenBefore {
	//变量1
	private  static int a = 0;
	//变量2
	private static boolean flag = false;
	public static void main(String[] args) throws InterruptedException {
		for(int i=0;i<10;i++) {
			a = 0;
			flag = false;
			
			//线程1 更改数据
			Thread t1 = new Thread(()->{
				a = 1;
				flag = true;
			}) ;
			//线程2 读取数据
			Thread t2 = new Thread(()->{
				if(flag) {
					a *=1;
				}
				//指令重排
				if(a == 0) {
					System.out.println("happen before a->"+a);
				}
			}) ;
			
			t1.start();
			t2.start();
			
			//合并线程
			t1.join();
			t2.join();
		}
	}

}

在这里插入图片描述
a的值还没回来，就去执行下一条指令了

存在着指令重排

volitale

在这里插入图片描述
保证你的数据都是最新的
VolatileTest.java

package com.sxt.others;
/**
 * volatile用于保证数据的同步，也就是可见性
 */
public class VolatileTest {
	private volatile static int num = 0;
	public static void main(String[] args) throws InterruptedException {
		new Thread(()->{
			while(num==0) { //此处不要编写代码
				
			}
		}) .start();
		
		Thread.sleep(1000);
		num = 1;
	}

}
不加volatile ，不会停死循环。加了以后就会1秒后停止了循环。
保证数据的同步，可见性。

scl单例模式

在这里插入图片描述
装饰模式、静态代理、单例模式
DoubleCheckedLocking.java

package com.sxt.others;
/**
 * DCL单例模式: 懒汉式套路基础上加入并发控制，保证在多线程环境下，对外存在一个对象
 * 1、构造器私有化 -->避免外部new构造器
 * 2、提供私有的静态属性 -->存储对象的地址
 * 3、提供公共的静态方法 --> 获取属性
 */
public class DoubleCheckedLocking {
	//2、提供私有的静态属性
	//没有volatile其他线程可能访问一个没有初始化的对象,保证同步更新。
	private static volatile DoubleCheckedLocking instance;	
	//1、构造器私有化 
	private DoubleCheckedLocking() {		
	}
	//3、提供公共的静态方法 --> 获取属性
	public static DoubleCheckedLocking getInstance() {	
		//再次检测
		if(null!=instance) { //避免不必要的同步 ，已经存在对象
			return instance;
		}
		synchronized(DoubleCheckedLocking.class) {//避免创建两个对象，所以这里同步，锁定这个class
			if(null == instance) {				
				instance = new DoubleCheckedLocking();
				//1、开辟空间 //2、初始化对象信息 //3、返回对象的地址给引用
			}
		}
		return instance;
	}	
	public static DoubleCheckedLocking getInstance1(long time) {		
			if(null == instance) {
				try {
					Thread.sleep(time);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				instance = new DoubleCheckedLocking();
				//1、开辟空间 //2、初始化对象信息 //3、返回对象的地址给引用
			}
		return instance;
	}
	public static void main(String[] args) {
		Thread t = new Thread(()->{
			System.out.println(DoubleCheckedLocking.getInstance());
		}) ;
		t.start();
		System.out.println(DoubleCheckedLocking.getInstance());
	}

}

在这里插入图片描述
不加入同步getInstance1

ThreadLocal

在这里插入图片描述

ThreadLocalTest01.java

package com.sxt.others;
/**
 * ThreadLocal:每个线程自身的存储本地、局部区域
 *  get/set/initialValue
 */
public class ThreadLocalTest01 {
	//private static ThreadLocal<Integer> threadLocal = new ThreadLocal<> ();
	//更改初始化值
	/*private static ThreadLocal<Integer> threadLocal = new ThreadLocal<> () {
		protected Integer initialValue() {//重写initialValue
			return 200;
		}; 
	};*/
	private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(()-> 200);//lamda
	public static void main(String[] args) {
		//获取值
		System.out.println(Thread.currentThread().getName()+"-->"+threadLocal.get());		
		//设置值
		threadLocal.set(99);
		System.out.println(Thread.currentThread().getName()+"-->"+threadLocal.get());
		
		new Thread(new MyRun()).start();//子线程
		new Thread(new MyRun()).start();//子线程
	}	
	public static  class MyRun implements Runnable{
		public void run() {
			threadLocal.set((int)(Math.random()*99));
			System.out.println(Thread.currentThread().getName()+"-->"+threadLocal.get());		
		}
	}
	
}

在这里插入图片描述

ThreadLocalTest02java

package com.sxt.others;
/**
 * ThreadLocal:每个线程自身的数据，更改不会影响其他线程
 * @author 裴新 QQ:3401997271
 *
 */
public class ThreadLocalTest02 {	
	private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(()-> 1);
	public static void main(String[] args) {
		for(int i=0;i<5;i++) {
			new Thread(new MyRun()).start();
		}
	}	
	public static  class MyRun implements Runnable{
		public void run() {
			Integer left =threadLocal.get();
			System.out.println(Thread.currentThread().getName()+"得到了-->"+left);		
			threadLocal.set(left -1);
			System.out.println(Thread.currentThread().getName()+"还剩下-->"+threadLocal.get());	
		}
	}
	
}

在这里插入图片描述

ThreadLocalTest03.java

    package com.sxt.others;
/**
 * ThreadLocal:分析上下文 环境  起点
 * 1、构造器: 哪里调用 就属于哪里 找线程体
 * 2、run方法:本线程自身的
 */
public class ThreadLocalTest03 {	
	private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(()-> 1);
	public static void main(String[] args) {
		new Thread(new MyRun()).start();
		new Thread(new MyRun()).start();
	}	
	public static  class MyRun implements Runnable{
		public MyRun() {
			threadLocal.set(-100);
			System.out.println(Thread.currentThread().getName()+"-->"+threadLocal.get());	
		}
		public void run() {
			System.out.println(Thread.currentThread().getName()+"-->"+threadLocal.get());	
			//new Thread(new MyRunxxx()).start();
		}
	}
	
}

在这里插入图片描述

ThreadLocalTest04.java
 package com.sxt.others;
/**
 * InheritableThreadLocal:继承上下文 环境的数据 ，拷贝一份给子线程
 */
public class ThreadLocalTest04 {	
	private static ThreadLocal<Integer> threadLocal = new InheritableThreadLocal<>();
	public static void main(String[] args) {
		threadLocal.set(2);
		System.out.println(Thread.currentThread().getName()+"-->"+threadLocal.get());	
		
		//线程由main线程开辟
		new Thread(()->{
			System.out.println(Thread.currentThread().getName()+"-->"+threadLocal.get());	
			threadLocal.set(200);
			System.out.println(Thread.currentThread().getName()+"-->"+threadLocal.get());	
		}) .start();
		
	}		
}

在这里插入图片描述

可重入锁

在这里插入图片描述
保证并发
LockTest01.java

package com.sxt.others;
/**
 * 可重入锁: 锁可以延续使用
 */
public class LockTest01 {
	public void test() {
	//  第一次获得锁
        synchronized(this) {
            while(true) {
                //  第二次获得同样的锁
                synchronized(this) {
                    System.out.println("ReentrantLock!");
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
	}
	public static void main(String[] args) {
		new LockTest01().test();
	}

}

LockTest02.java

package com.sxt.others;
/**
 * 不可重入锁: 锁不可以延续使用
 */
public class LockTest02 {
	Lock lock = new Lock();
	public void a() throws InterruptedException {
		lock.lock();
		doSomething();
		lock.unlock();
	}
	//不可重入
	public void doSomething() throws InterruptedException {
		lock.lock();
		//...................
		lock.unlock();
	}
	public static void main(String[] args) throws InterruptedException {
		LockTest02 test = new LockTest02();
		test.a();
		test.doSomething();
	}

}
// 不可重入锁
class Lock{
	//是否占用
	private boolean isLocked = false;
	//使用锁
	public synchronized void lock() throws InterruptedException {
		while(isLocked) {
			wait();
		}
		
		isLocked = true;
	}
	//释放锁
	public synchronized void unlock() {
		isLocked = false;
		notify();
		
	}
}

LockTest03.java

package com.sxt.others;
/**
 * 可重入锁: 锁可以延续使用 + 计数器
 */
public class LockTest03 {
	ReLock lock = new ReLock();
	public void a() throws InterruptedException {
		lock.lock();
		System.out.println(lock.getHoldCount());
		doSomething();
		lock.unlock();
		System.out.println(lock.getHoldCount());
	}
	//不可重入
	public void doSomething() throws InterruptedException {
		lock.lock();
		System.out.println(lock.getHoldCount());
		//...................
		lock.unlock();
		System.out.println(lock.getHoldCount());
	}
	public static void main(String[] args) throws InterruptedException {
		LockTest03 test = new LockTest03();
		test.a();			
		Thread.sleep(1000);		
		System.out.println(test.lock.getHoldCount());
	}

}
// 可重入锁
class ReLock{
	//是否占用
	private boolean isLocked = false;
	private Thread lockedBy = null; //存储线程
	private int holdCount = 0;
	//使用锁
	public synchronized void lock() throws InterruptedException {
		Thread t = Thread.currentThread();
		while(isLocked && lockedBy != t) {
			wait();
		}
		
		isLocked = true;
		lockedBy = t;
		holdCount ++;
	}
	//释放锁
	public synchronized void unlock() {
		if(Thread.currentThread() == lockedBy) {
			holdCount --;
			if(holdCount ==0) {
				isLocked = false;
				notify();
				lockedBy = null;
			}		
		}		
	}
	public int getHoldCount() {
		return holdCount;
	}
}

LockTest04.java

package com.sxt.others;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 可重入锁: 锁可以延续使用 + 计数器
 */
public class LockTest04 {
	ReentrantLock lock = new ReentrantLock();
	public void a() throws InterruptedException {
		lock.lock();
		System.out.println(lock.getHoldCount());
		doSomething();
		lock.unlock();
		System.out.println(lock.getHoldCount());
	}
	//不可重入
	public void doSomething() throws InterruptedException {
		lock.lock();
		System.out.println(lock.getHoldCount());
		//...................
		lock.unlock();
		System.out.println(lock.getHoldCount());
	}
	public static void main(String[] args) throws InterruptedException {
		LockTest04 test = new LockTest04();
		test.a();			
		Thread.sleep(1000);		
		System.out.println(test.lock.getHoldCount());
	}

}

CAS原子操作

在这里插入图片描述
CAS.java

package com.sxt.others;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * CAS:比较并交换
 */
public class CAS {
	//库存
	private static AtomicInteger stock = new AtomicInteger(5);
	public static void main(String[] args) {
		for(int i=0;i<5;i++) {
			new Thread(()->{
				//模拟网络延时
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				Integer left = stock.decrementAndGet();
				if(left<1) {
					System.out.println("抢完了...");
					return ;
				}
				System.out.print(Thread.currentThread().getName()+"抢了一件商品");
				System.out.println("-->还剩"+left);
			}) .start();
		}
	}

}

在这里插入图片描述

总结

1.程序：Java源程序和字节码文件被称为“程序(Program)”，是一个静态的概念。
2.进程：执行中的程序叫做进程(Process)，是一个动态的概念。每个进程由3部分组成：cpu、data、code。
3.线程：是进程中一个“单一的连续控制流程 (a single sequential flow of control)”。
4.在Java中实现多线程的方式：
▪ 继承Thread类实现多线程
▪ 实现Runnable接口实现多线程
5.线程的状态：
▪ 新生状态
▪ 就绪状态
▪ 运行状态
▪ 死亡状态
▪ 阻塞状态
6.暂停线程执行的方法:
▪ sleep()
▪ yield()
▪ join()
7.实现线程同步的两种方式：（保证并发的安全就要用同步）
▪ synchronized 方法：
public synchronized void accessVal(int newVal);
▪ synchronized 块：
synchronized(syncObject)
{
//允许访问控制的代码
}
8.同步解决问题的另一种典型方式：生产者/消费者模式。
9.线程通信的方法：
▪ wait()
▪ notify()
▪ notifyAll()
都是Object类的方法，只能在同步方法和同步代码块中使用。

A记录学习路线

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础5多线程技术

11.1 基本概念多线程是Java语言的重要特性，大量应用于网络编程、服务器端程序的开发，最常见的UI界面底层原理、操作系统底层原理都大量使用了多线程。我们可以流畅的点击软件或者游戏中的各种按钮，其实，底层就是多线程的应用。UI界面的主线程绘制界面，如果有一个耗时的操作发生则启动新的线程，完全不影响主线程的工作。当这个线程工作完毕后，再更新到主界面上。我们可以上百人、上千人、上万人同时访问某...
复制链接

扫一扫

专栏目录