Java学习笔记2——多线程详解

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java学习笔记2——多线程详解，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含19029字，纯文字阅读大概需要28分钟。

内容图文

1. 线程简介

程序：静态概念，是指令和数据的有序集合。
进程：动态概念，执行程序的一次执行过程，是系统资源分配的单位。
线程：独立的执行路径，每一个线程都有自己的局部变量表、程序计数器（指向正在执行的指令指针）以及各自的生命周期。

• 一个进程Process至少有一个线程Thread，线程是CPU调度和执行的单位。
• 线程运行由调度器安排调度，调度器与操作系统紧密相关，先后顺序不能人为干预。
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程。
• main()称之为主线程，为系统的入口，用于执行整个程序。
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。
• 线程会带来额外的开销，如CPU调度时间，并发控制开销。
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。
• 线程启动必须在其中一个任务之前，否则线程将永远得不到启动，因为前一个任务永远不会结束。
• 借助Jconsole或者Jstack命令查看线程。
  

注意：很多多线程是模拟出来的，即在同一CPU下，同一个时间点只执行一个代码，因为切换很快，所以有同时执行的错觉。真正的多线程是指有多个CPU，即多核，如服务器。

2. 线程实现

2.1 线程创建

方法一：继承Thread类

（实现了Runnable接口）
每个线程都有优先权（但最终仍由CPU决定）。每个线程可能也可能不会被标记为守护程序。当在某个线程中运行的代码创建一个新的Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护线程。
不建议使用：避免OOP单继承局限性
实现：将一个类声明为Thread的子类，该子类重写run类的方法Thread，然后分配并启动子类的实例。

public class TestThread extends Thread{
	@override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println("我在看代码");
		}
	}
	public static void main(String[] args) {
		TestThread testThread = new TestThread();
		testThread.start();  // 同时交替进行
		// 线程开启不一定立即执行，由CPU调度
		testThread.run(); // 先调用run方法（错误） 
		for (int i = 0; i < 20; i++) {
			System.out.println("多线程");
		}
	}
}

案例：多线程下载图片
下载commons-io.jar包

public class TestThread extends Thread{
	private String url;
	private String name;
	public TestThread(String url,String name){
		this.url = url;
		this.name = name;
	}
	@override
	public void run(){
		WebDownLoader webDownloder = new WebDownLoader();
		webDownloder.downloder(url,name);
	}
	public static void main(String[] args){
		TestThread t1 = new TestThread("https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3403164926,2805624001&fm=26&gp=0.jpg","1.jpg");
		t1.start();
	}
}
class WebDownLoader{
	public woid downloder(String url,String name){
		try{
			FileUtils.copyURLToFile(new URL(url), new File(name));
		}catch(IOException e){
			e.printStackTrace();
			System.out.println("IO异常");
		}
	}
}

方法二：实现Runnable接口

声明实现类Runnable接口，该类重写run方法，通过分配类的实例，在创建Thread时作为参数传递并启动。
启动线程：传入目标对象+Thread对象.start()
推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

public class TestThread implements Runnable{
	@override
	public void run(){
		for (int i = 0; i < 20; i++){
			System.out.println("代码");
		}
	}
	public static void main(String[] args){
		TestThread testThread = new TestThread();
		
		Thread thread = new Thread(testThread);
		thread.start();
		//new Thread(testThread).start();
		
		for (int i = 0; i < 20; i++) {
			System.out.println("多线程");
		}
	}
}

案例：买火车票

public class TestThread implements Runnable(){
	private int ticketNums = 10;
	@override
	public void run(){
		while (true) {
			if (ticketNums <= 0){
				break;
			}
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getNames()+"拿到了第"+ticketNames--+"票");
		}
	}
	public static void main(String[] args) {
		TestThread ticket= new TestThread();
		new Thread(ticket,"小明").start();
		new Thread(ticket,"老师").start();
		new Thread(ticket,"黄牛党").start();
	}
}

案例：龟兔赛跑

public class Race implements Runnable {
	private static String winner;
	@override
	public void run() {
		for (int i = 0; i <= 100; i++) {
			//模拟兔子休息
			if (Thread.currentThread().getName().equals("兔子") && i%10==0) {
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}			
			//判断比赛是否结束
			boolean glag = gameOver(i);
			if (flag){
				break;
			}
			System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步";
		}
	}
	private boolean gameOver() {
		if (winner != null) {
			return true;
		}{
			if (steps >= 100){
				winner = Thread.currentThread().getName();
				System.out.println("winner is "+winner);
				return true;
			}
		}
		return false;
	}
	public static void main(String[] args) {
		Race race = new Race();
		new Thread(race, "兔子").start();
		new Thread(race, "乌龟").start();
	}
}

方法三：实现Callable接口

实现Callable接口需要返回值类型，重写call方法，需要抛出异常。
优点：1.可以定义返回值；2.可以抛出异常。
创建目标对象
创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行：Future result1 = ser.submit(t1);
获取结果：boolean r1 = result1.get();
关闭服务：ser.shutdownNow();

public class TestCallable implements Callable<Boolean>{
	private String url;
	private String name;
	public TestThread(String url,String name){
		this.url = url;
		this.name = name;
	}
	@Override
	public Boolean call(){
		WebDownLoader webDownloder = new WebDownLoader();
		webDownloder.downloder(url,name);
		return true;
	}
	public static void main(String[] args){
		TestCallable t1 = new TestCallable ("https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3403164926,2805624001&fm=26&gp=0.jpg","1.jpg");
		t1.start();
		ExecutorService ser = Executors.newFixedThreadPool(1);
		Future<Boolean> r1= ser.submit(t1);
		boolean rs1 = r1.get();
		ser.shutdownNow();
	}
}
class WebDownLoader{
	public woid downloder(String url,String name){
		try{
			FileUtils.copyURLToFile(new URL(url), new File(name));
		}catch(IOException e){
			e.printStackTrace();
			System.out.println("IO异常");
		}
	}
}

2.2 静态代理

静态代理模式：真实对象和代理对象都要实现同一个接口。代理对象要代理真实角色。
好处：代理对象可以做很多真实对象做不了的事情，真实对象专注做自己的事。

public class Dome1 {
	public static void main(String[] args){
		                    // 代理runnable接口
		// new Thread(()->System.out.println("i love you")).start();
		Company company = new Company(new You());
		company.happymarry();
	} 
}
interface Marry {
	void happymarry();
}
class You implements Marry {
	@Override
	public void happymarry() {
		System.out.println("i am happy!");
	}
}
class Company(You) implements Marry {
	private Marry target; // 传真实对象
	
	public Company(Marry target) {
		this.target = target;
	}
	@Override
	public void happymarry() {
		before();
		this.target.happymarry();
		after();
	}
	public void before() {
		System.out.println("prepare!");
	}
	public void after() {
		System.out.println("we are happy!");
	}
}

2.3 Lambda表达式

其实质属于函数式编程的概念，避免匿名内部类定义过多。
函数式接口的定义：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口，可以通过Lambda表达式来创建该接口的对象。

(params) -> expression[表达式]
(params) -> statement[语句]
(params) -> {statements}

a -> System.out.println("i like lambda-->" + a);
new Thread (()->System.out.println("多线程学习。。")).start();

//简化过程:
public class Test {
	//3.静态内部类
	static class Like2 implements iLike{
		@Override
		public void lambda() {
			System.out.println("i like lambda2");
		}
	}
	public static void main(String[] args) {
		iLike like = new Like();
		like.lambda(); //2.
		like = new Like2();
		like.lambda(); //3.

		//4.局部内部类
		class Like3 implements iLike{
			@Override
			public void lambda() {
				System.out.println("i like lambda3");
			}
		like = new Like3();
		like.lambda();//4.
		//5.匿名内部类
		like = new iLike() {//new 接口
			@Override
			public void lambda() {
				System.out.println("i like lambda4");
			}
		};
		like.lambda();
		//6.用Lambda简化
		like = ()->{
			System.out.println("i like lambda5");
		};//只有一行代码可以不用花括号
		like.lambda();
	}
}
//1.定义一个函数式接口
interface iLike{
	void lambda();
}	
//2.实现类
class Like implements iLike{
	@Override
	public void lambda() {
		System.out.println("i like lambda");
	}
}

3. 线程状态

1. 创建状态
   |启动线程 new
2. 就绪状态
   |阻塞解除——获得CPU资源
3. 阻塞状态
4. 运行状态
   |线程自然执行完毕或外部干涉终止线程
5. 死亡状态

不推荐使用stop、destroy方法（已废弃）；推荐线程自己停止下来——建议使用一个标志位进行终止变量，当flag=False，则终止线程运行。

public class Teststop implements Runnable {
	//1.定义标识
	private boolean flag = true;
	@Override
	public void run() {
		//2.使用该标识
		while (flag) {
			System.out.println("run...Thread");
		}
	}
	//3.对外提供方法改变标识
	public void stop(){
		this.flag = false;
	}
}

3.1 线程休眠

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

//模拟倒计时
public class Test {
	public static void main(String[] args){
		Date statTime = new Date(System.currentTimeMillis());
		try {
			System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
			tenDown();
			statTime = new Date(System.currentTimeMillis());//更新时间
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	public static void tenDown() throws InterruptedException {
		int num = 10;
		while (true) {
			Thread.sleep(1000);
			System.out.println(num--);
			if (num == 0){
				break;
			}
		}
	}
}

3.2 线程礼让

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

public class Test {
	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.3 多线程强制执行join

Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞，类似于插队。

public class Test implements Runnable{
	public static void main(String[] args) throws InterruptedException {
		Test test = new Test();
		Thread thread = new Thread(test);
		thread.start();
		for (int i = 0; i < 100; i++) {
			if (i == 50){
				thread.join();
			}
			System.out.println("main...." + i);
		}
	}
	@Override 
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("join..." + i);
		}
	}
}

3.4 线程状态观测

Thread.State

• NEW：尚未启动的线程
• RUNNABLE：在JVM中执行的线程
• BLOCKED：被阻塞等监视器锁定的线程
• WAITING：正在等待另一个线程执行特定动作的线程
• TIMED WAITING：正在等待另一个线程执行动作达到指定等待时间的线程
• TERMINATED：已退出的线程

public class Test {
	public static void main(String[] args) {
		Thread thread = new Thread(()->{
			for (int i = 0; i < 5; i++) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e){
					e.printStackTrace();
				}
			}
			System.out.println("/");
		});
		Thread.State state = thread.getState();
		System.out.println(state);//NEW
		thread.start();
		state = thread.getState();
		System.out.println(state);//RUN
		while (state != Thread.State.TERMINATED){//只要线程不终止，一直输出
			Thread.sleep(1000);
			state = thread.getState();
			System.out.println(state);
		}
	}
}

3.5 线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围从1-10.

• Thread.MIN_PRIORITY = 1;
• Thread.MAX_PRIORITY = 10;
• Thread.NORM_PRIORITY = 5;

使用以下方式改变或获取优先级getPriority()、setPriority(int xxx)。
先设置优先级再启动。性能倒置：优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度。

3.6 守护线程daemon

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

public class Test {
	public static void main(String[] args) {
		God god = new God();
		You you = new You();
		Thread thread = new Thread(god);
		thread.setDaemon(true);//默认是False为用户线程，正常线程都是用户线程
		thread.start();
		new Thread(you).start();
	}
}
class God implements Runnable{
	@Override
	public void run(){
		while (true) {
			System.out.println("god blessing you");
		}
	}
}
class You implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 36500; i++){
			System.out.println("happy living");
		}
		System.out.println("====goodbye:world!====");
	}

4. 线程同步

4.1 线程同步

并发：同一个对象被多个线程同时操作。
线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待使用后释放锁即可。
存在以下问题：

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

synchronized关键字，它包括两种用法：synchronized方法和synchronized块。

1. synchronized方法：

public synchronized void method(int args){}

2. synchronized块：
   synchronized(Obj){}
   Obj称之为同步监视器，可以是任何对象，推荐使用共享资源作为同步监视器。同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class。
   缺陷：若将一个大的方法申明为synchronized将会影响效率。

案例：买火车票

public class Test {
	public static void main(String[] args){
		BuyTicket station = new BuyTicket();
		new Thread(station,"a").start();
		new Thread(station,"b").start();
		new Thread(station,"c").start();
}
class BuyTicket implements Runnable{
	private int ticketNum = 10;//保证数据对象只能被方法访问，get/set
	boolean flag = true;
	@Override
	public void run(){
		while (flag){//线程停止
			try{
				buy();
			} catch (InterruptedException e){
				e.printStackTrace();
			}
		}
	}
	//同步方法，锁的是this
	public synchronized void buy() throws InterruptedException {
		if (ticketNum <= 0){
			flag = false;
			return;
		}
		Thread.sleep(100);//模拟延时可以放大问题的发生性
		System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
	}
}

4.2 JUC

import java.util.concurrent.CopyOnWriteArrayList;
public class Test {
	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(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(list.size());
	}
}

4.3 死锁

导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

产生死锁的四个必要条件：（想办法避免其中一个或多个）

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

4.4 Lock（锁）

从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁Lock对象来实现同步。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
可重入锁ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁（synchronized是隐式锁，出了作用域自动释放）。
异同点：Lock只有代码块锁，synchronized有代码块锁和方法锁。使用Lock锁，JVM花费较少的时间来调度线程，性能更好，有更多扩展性（子类）。
优先顺序：Lock>同步代码块（已经进入方法体，分配了相应资源）>同步方法

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

5. 线程通信问题

生产者消费者问题：生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。
synchronized可阻止并发更新同一个共享资源，实现同步，但不能实现线程之间的消息传递。

解决方法1：管程法——缓冲区

public class Test{
	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;
	}
	@Override
	public void run(){
		for (int i = 0; i < 100; i++){
			container.push(new chicken(i));
			System.out.println("生产了"+i+"只鸡");
		}
	}
}
class Consumer extends Thread{
	SynContainer container;
	public Productor(SynContainer container){
		this.container = container;
	}
	@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){
		this.id = id;
	}
}
class SynContainer{
	Chicken[] chickens = new Chicken[10];//需要一个容器大小
	int count = 0;//容器计数器
	//生产者放入
	public synchronized void push(Chicken chicken){
		//如果容器满了
		if (count==chickens.length){
			try {
				this.wait();//通知消费消费，生产者等待
			}catch (InterruptedException e){
				e.ptintStackTrace();
			}
		}
		chickens[count] = chicken;//如果容器没有满
		count++;
		this.notifyAll();//通知消费者消费
	}
	//消费者消费
	public synchronized Chicken pop(){
		if (count==0){
			try{//通知生产
				this.wait();
			}catch (InterruptedException e){
				e.printStackTrace();
			}
		}
		count--;
		Chicken chicken = chichens[count];
		this.notifyAll();
		return chicken;
}

解决方法2：信号灯法——标志位

public class Test(){
	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 Player(TV tv){
		this.tv = tv;
	}
	@Override
	public void run(){
		for (int i=0; i<20; i++){
			tv.watch();
		}
	}
}
class TV{
	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.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;
	}
}

6. 高级主题

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
线程池：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止

JDK5.0提供了线程池相关API：

• ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
  void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
  Futuresubmit(Callabletask)：执行任务，有返回值，一般又来执行Callable
  void shutdown()：关闭连接池
• Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test{
	public static void main(String[] args){
		//1.创建服务，创建线程池：参数为线程池大小
		ExecutorService service = Executors.newFixedThreadPool(10);
		//2.执行
		service.execute(new MyThread());
		service.execute(new MyThread());
		service.execute(new MyThread());
		//3.关闭链接
		service.shutdown();
	}
}
class MyThread implements Runnable{
	@Override
	public void run(){
		for(int i = 0; i<100; i++){
			System.out.println(Thread.currentThread().getName()+i);
		}
	}
}

内容总结

以上是互联网集市为您收集整理的Java学习笔记2——多线程详解全部内容，希望文章能够帮你解决Java学习笔记2——多线程详解所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端