多线程学习笔记-CSDN博客

本文链接：https://blog.csdn.net/weixin_44491927/article/details/113928576

多线程

1. 概述

普通线程和多线程

进程
- 进程就是执行程序的一次执行过程,它是一个动态的概念,式系统资源分配的单位
- 通常再一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是CPU调度和执行的单位
线程
- 线程就是独立的执行路径
- 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程
- main()称之为主线程,为系统的入口,用于执行整个程序
- 在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排调度的,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的
- 对同一份资源操作时mm会存在资源抢夺的问题,需要加入并发控制
- 线程会带来额外的开销,如CPU调度时间,并发控制开销
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

2. 线程创建

Thread Runnable Callable

1）继承Thread类

//对应P3  继承Threa实现线程
public class ThreadTest01 extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"执行了");
    }

    public static void main(String[] args) {
        ThreadTest01 threadTest01 = new ThreadTest01();
        threadTest01.start();
    }
}

2）实现Runnable接口

主要推荐这种方法实现线程，一个类的对象可以被多个线程使用

新建类继承Runnable接口后，就变成了线程类
重写run方法—线程的执行题
将线程类实例化丢给 Thread类的对象，然后对象启动start

public class TestRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("实现了run方法");
    }
}

  public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();

        Thread thread = new Thread(new TestRunnable());
        thread.start();
    }

3）Callable

实现Callable接口,重写call方法,
可以定义返回值
可以抛出异常

public class TestCallable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        System.out.println("创建成功");
        return true;
    }

    public static void main(String[] args) {
        TestCallable callable = new TestCallable();
        //方法一
        //创建执行服务
        ExecutorService service = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> result = service.submit(callable);
        //接收返回值
        try {
			boolean isTrue = result.get();
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
        service.shutdownNow();
        
        //方法二
        FutureTask<Boolean> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();

    }

}

3. 静态代理模式

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

好处：

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

package mythread;

public class ThreadDemo {
	public static void main(String[] args) {
		WeddingCompany weddingCompany = new WeddingCompany(new You());
		weddingCompany.getMarry();
	}

}
interface Marry {
	void getMarry();
}

// 真实角色
class You implements Marry {

	@Override
	public void getMarry() {
		// TODO 自动生成的方法存根
		System.out.println("焦前进要结婚了，哈哈哈哈哈");
	}
}

//婚庆公司 代理对象，要去代理正式角色
class WeddingCompany implements Marry {
	
	private Marry target;
	
	WeddingCompany(Marry target) {
		this.target = target;
	}

	@Override
	public void getMarry() {
		// TODO 自动生成的方法存根
		
		before();
		this.target.getMarry();
		after();
		
	}

	private void after() {
		// TODO 自动生成的方法存根
		System.out.println("结婚前，布置现场");
		
	}

	private void before() {
		// TODO 自动生成的方法存根
		System.out.println("结婚后，清理");
		
	}
	
}

4. Lambda表达式

避免匿名内部类定义过多

其实质属于函数式编程的概念

可以让代码看起来很简洁

去掉了一堆没有意义的代码，只留下核心的逻辑

package mythread;

public class LamdaDemo {
	// 2. 静态内部类
	static class Love2 implements Ilove{

		@Override
		public void lamda() {
			// TODO 自动生成的方法存根
			System.out.println("I Love lamda02");
		}
		
	}
	public static void main(String[] args) {
		Love1 love1 = new Love1();
		love1.lamda();
		
		Love2 love2 = new Love2();
		love2.lamda();
		
		// 3. 局部内部类
		class Love3 implements Ilove{

			@Override
			public void lamda() {
				// TODO 自动生成的方法存根
				System.out.println("I Love lamda03");
			}
			
		}
		Love3 love3 = new Love3();
		love3.lamda();
		
		// 4. 匿名内部类
		
		Ilove love4 = new Ilove() {
			
			@Override
			public void lamda() {
				// TODO 自动生成的方法存根
				System.out.println("I Love lamda04");
			}
		};
		love4.lamda();
		
		// 5. lamda表达式
		Ilove love5 = () -> {
			System.out.println("I Love lamda05");
		};
		love5.lamda();
	}

}
// 定义一个接口，只有一个方法，为函数式接口
interface Ilove{
	void lamda();
}

// 1. 外部类
class Love1 implements Ilove{

	@Override
	public void lamda() {
		// TODO 自动生成的方法存根
		System.out.println("I Love lamda01");
	}
	
}

lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块包裹
前提是接口为函数式接口
多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号。

5. 线程状态

创建状态
就绪状态
阻塞状态
运行状态
死亡状态

1）线程停止

public class TestStop implements Runnable {
    private boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("run.....Thread"+(i++));
        }
    }
    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i <1000 ; i++) {
            System.out.println("main"+i);
            if (i==900){
                testStop.stop();
                System.out.println("线程停止了！");
            }
        }
    }
}

2）线程休眠 sleep()

sleep(毫秒数)指定当前线程停止的实践
sleep()存在异常InteruptedException
sleep()实践到达后线程进入就绪状态
sleep()可以模拟网络延时,倒计时等
每一个对象都有一个锁,sleep不会释放锁

每隔一秒，打印当前系统时间

package mythread;

import java.text.SimpleDateFormat;
import java.util.Date;

public class printCurrentTime {
	
	public static void main(String[] args) {
		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 自动生成的 catch 块
				e.printStackTrace();
			}	
		}	
	}
}

3）线程礼让 yield()

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

4）线程强制执行join()

Join合并线程,待此线程执行完成后,在执行其他线程,其他线程阻塞
可以想象成插队

5）线程状态观测

 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) {
                    e.printStackTrace();
                }
            }
        });
        Thread.State state = thread.getState();
        System.out.println(state);//new
        thread.start();//启动线程
        state=thread.getState();//runnable
        System.out.println(state);
        while (state!= Thread.State.TERMINATED){//只要线程不终止就输入线程状态
            Thread.sleep(100);
            state=thread.getState();
            System.out.println(state);
        }
    }

6）线程优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。

线程的优先级用数字表示，范围从1~10。

使用以下方式改变或获取优先级

getPriority().setPriority(int xxx)

注意：先设置优先级，再start线程！！！

7）守护线程

package mythread;

public class TestDaemon {
	public static void main(String[] args) {
		God god = new God();
		Man you = new Man();
		
		Thread thread = new Thread(god);
		thread.setDaemon(true);
		
		thread.start();
        
		new Thread(you).start();
	}	
}

class God implements Runnable{

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		while (true) {
			System.out.println("上帝一直守护着你");
		}
	}
	
}
class Man implements Runnable {

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		for (int i = 0; i < 36500; i++) {
			System.out.println("我健康快乐的活着");
		}
		System.out.println("我离开了这个世界");
	}
	
}

6. 线程同步

由于同一进城的多个线程共享同一块存储空间，在带来方便的同事，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：
一个线程持有锁会导致其它所有需要此锁的线程挂起；
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

1）线程不安全的例子

多人买票

package unsafe;

public class Demo01 {

	public static void main(String[] args) {
		BuyTicket bt=new BuyTicket();
		new Thread(bt,"我").start();
		new Thread(bt,"你").start();
		new Thread(bt,"黄牛党").start();
	}
}

class BuyTicket implements Runnable{
	//票
	private int ticketNums=10;
	boolean flag=true;//外部停止方式
	@Override
	public void run() {
		//买票
		while (flag){
			buy();
		}
	}


	public synchronized void buy(){//锁了方法，相当于this 把类给锁住

		//判断是否有票
		if(ticketNums<=0){
			System.out.println("票没了");
			flag=false;
			return ;
		}
		//模拟延时
	    try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+ticketNums--);
	}
}

不安全取钱

//不安全取钱
    //两个人去银行取钱，账户
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,"女朋友");
        you.start();
        girlFriend.start();
    }
}
//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        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;

    }
    //取钱

    @Override
    public void run() {
        synchronized (account) {//锁的对象是变化的量，锁需要增删改的对象
            //判断有没有钱
            if (account.money - drawingMoney <= 0) {
                System.out.println(Thread.currentThread().getName() + "钱不够");
                return;
            }
            //卡内余额
            account.money -= drawingMoney;
            //手里的钱
            nowMoney += drawingMoney;
            System.out.println(account.name + "余额为:" + account.money);
            System.out.println(this.getName() + "手里的钱:" + nowMoney);
        }
    }
}

线程不安全的集合

package unsafe;

import java.util.ArrayList;

public class UnsafeList {
	public static void main(String[] args) {
		ArrayList<String> list=new ArrayList<String>();
		for (int i = 0; i <1000 ; i++) {
			new Thread(()->{
				synchronized (list){
					list.add(Thread.currentThread().getName());
				}
			}).start();

		}
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(list.size());
	}
}

2）同步块

Synchronized(Obj){}

Obj称之为同步监视器

Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this,就是这个对象本身，或者是class【反射中讲解】

同步监视器的执行过程：

第一个线程访问，锁定同步监视器，执行其中代码
第二个线程访问，发现同步监视器被锁定，无法访问
第一个线程访问完毕，皆出同步监视器
第二个线程访问，发现同步监视器没有锁

3）死锁

产生死锁的四个条件

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

7. lock锁

JDK5.0开始，java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

synchronized与Lock的对比
- Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块加锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
- 优先使用顺序：
- Lock》同步代码块（已经进入了方法体，分配了相应资源）》同步方法（在方法体之外）

package locktest;

import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
	public static void main(String[] args) {
		BuyTicket buyTicket = new BuyTicket();
		
		new Thread(buyTicket).start();
		new Thread(buyTicket).start();
		new Thread(buyTicket).start();
	}

}

class BuyTicket implements Runnable {
	private int ticketName = 10;
	
	// 定义lock锁
	private final ReentrantLock lock = new ReentrantLock();
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		while(true) {
			try {
				lock.lock(); // 加锁
				if (ticketName > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
					System.out.println(ticketName --);
				} else {
					break;
				}
			} finally {
				// TODO: handle finally clause
				lock.unlock();//解锁
			}	
		}	
	}	
}

8. 线程协作

1）管程法

package locktest;

//测试生产者消费者模型 --->管程法

//产品
public class Product {
	private int id;

	public Product(int id) {
		this.id = id;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
	
	public static void main(String[] args) {
		SyncContainer container = new SyncContainer();
		new ProviderThread(container).start();
		new ConsumerThread(container).start();
	}
}

//消费者
class ConsumerThread extends Thread {

	private SyncContainer syncContainer;

	public ConsumerThread(SyncContainer syncContainer) {
		this.syncContainer = syncContainer;
	}

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			Product pop = syncContainer.pop();
			System.out.println("消费了第"+ pop.getId() + "号产品");
		}
	}
}


//生产者
class ProviderThread extends Thread {

	//创建好的缓冲区
	private SyncContainer syncContainer;

	public ProviderThread(SyncContainer syncContainer) {
		this.syncContainer = syncContainer;
	}

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			
			syncContainer.push(new Product(i));
			System.out.println("生产了" + i + "只鸡!");
		}
	}
}


//容器
class SyncContainer {

	//容器大小
	Product[] products = new Product[10];
	//容器计数器
	int count = 0;

	//生产者放入产品
	public synchronized void push(Product product){
		//如果容器满了,就要等待消费者
		//通知消费者消费,生产者等待
		if(count == products.length) {
			try {
				this.wait();
			} catch (InterruptedException e){
				e.printStackTrace();
			}
		}
		//如果容器没有满,就要生产产品
		products[count] = product;
		count++;
		//可以通知消费者消费
		this.notifyAll();
	}


	//消费者消费产品
	public synchronized Product pop(){
		//判断容器是否为空
		if(count == 0){
			//通知生产者生产.消费者等待
			try {
				this.wait();
			} catch (InterruptedException e){
				e.printStackTrace();
			}
		}

		//如果可以消费
		count--;
		Product product =  products[count];

		//通知生产者生产
		this.notifyAll();
		return product;
	}
}

2）信号灯法

package locktest;

public class TestPVC2 {
	public static void main(String[] args) {
		TV tv = new TV();
		new Watcher(tv).start();
		new Player(tv).start();
		
	}
}

class Player extends Thread {
	private TV tv = null;
	public Player(TV tv) {
		this.tv = tv;
	}
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		for (int i = 0; i < 100; i++) {
			tv.play( i + "号节目");
			
		}
	}
}
class Watcher extends Thread {
	private TV tv = null;
	public Watcher(TV tv) {
		this.tv = tv;
	}
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		for (int i = 0; i < 100; i++) {
			tv.watch();
			
		}
	}
}
//产品--》观众
class TV {

	//演员表演，观众等待
	//观众观看，演员等待
	private String voice;
	private boolean flag = false; //标志位
	public synchronized void play(String voice) {

		if (flag) {
			try {
				this.wait(); //等待观众观看
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				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) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
		System.out.println("观众观看了" + voice);
		this.notifyAll();// 通知演员表演
		this.flag = !this.flag;

	}
}

9. 线程池

背景: 经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大
思路: 提前创建好多个线程,放入线程池中,使用时直接获取,使用完毕放回池中,可以避免频繁的创建销毁,实现重复利用,类似生活中的工共交通工具
好处
- 提高了响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理(…)
  - corePoolSize: 核心池的大小
  - maximumPoolSize: 最大线程数
  - keepAliveTime: 线程没有任务时最多保持多长时间后会终止

package locktest;

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

public class Tool {
	public static void main(String[] args) {
		// 1. 创建服务，创建线程池
		ExecutorService service = Executors.newFixedThreadPool(10);
		
		// 执行
		service.execute(new MyThread());
		service.execute(new MyThread());
		service.execute(new MyThread());
		
		//2. 关闭连接
		service.shutdown();
	}

}
class MyThread implements Runnable {

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		System.out.println(Thread.currentThread().getName());
	}
	
}

线程的创建

package mythread;

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 java.util.concurrent.FutureTask;

public class ThreadNew {
	public static void main(String[] args) {
		new MyThread01().start();
		new Thread(new MyThread02()).start();
		
		//创建执行服务
        ExecutorService service = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> result = service.submit(new MyThread03());
        //接收返回值
        try {
			boolean isTrue = result.get();
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
        service.shutdownNow();
        
        FutureTask<Boolean> futureTask = new FutureTask<>(new MyThread03());
        new Thread(futureTask).start();
		
	}

}
class MyThread01 extends Thread {
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		System.out.println("thread01");
	}
}
class MyThread02 implements Runnable {

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		System.out.println("thread02");
	}
	
}
class MyThread03 implements Callable<Boolean> {

	@Override
	public Boolean call() throws Exception {
		// TODO 自动生成的方法存根
		System.out.println("thread03");
		return true;
	}
	
}
/* sout
thread01
thread02
thread03
thread03
*/