JavaSE--重新学习_查漏补缺(16)--多线程创建和启动_Thread类的有关方法_线程的生命周期_线程的同步_线程的死锁问题_线程间通信_经典线程同步---生产者/消费者问题

最新推荐文章于 2022-07-12 19:38:14 发布

小小卡尔

最新推荐文章于 2022-07-12 19:38:14 发布

阅读量152

点赞数

分类专栏： JavaSE学习文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/weixin_44185736/article/details/105062644

版权

JavaSE学习专栏收录该内容

21 篇文章 0 订阅

订阅专栏

文章目录

一、多线程

形象理解====多线程相当进程的支流，各走各的，假设在进程上跑的代码是主程序，当其中的第三行代码是开启线程的，那么开启线程之后，线程运行的代码就和主程序并行（即它们之间不相干了）

二、多线的创建和启动

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类和java.util.concurrent并发包下的Callable接口来实现。
创建线程有三种方式：

继承Thread类
实现Runnable接口
创建一个类实现Callable接口（本次不重点说这一个）

以上三种方式的前两种都是通过Thread类实现的，它们的启动方式如下：
创建对象Thread对象->调用start()->相当于调用run()，启动线程。
要实现线程代码的逻辑，只需将代码在run()方法中即可。
两者区别：
1. 继承Thread: 线程代码存放Thread子类run方法中。重写run方法
2. 实现Runnable：线程代码存在接口的子类的run方法。实现run方法
实现接口的好处：
1. 避免了单继承的局限性
2. 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
  所以一般使用实现接口方式来实现多线程
两种线程实现方法代码：
继承Thread方式

package ThreadDemo;

/**
 * 继承Thread实现多线程
 */

public class TestThrad extends Thread {
    @Override
    public void run(){
        System.out.println("多线程运行的代码");
        for(int i= 0 ; i<6 ; i++){
            System.out.println("这时多线程的逻辑代码");
        }
    }
}

实现Runnable接口

package ThreadDemo;

public class TestRunable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"Runable接口多线程运行的代码");
        for(int i= 0 ; i<6 ; i++){
            System.out.println(Thread.currentThread().getName()+"这是Runable接口多线程的逻辑代码");
        }
    }
}

测试类

package ThreadDemo;

public class Test {
    public static void main(String[] args) {
//        Thread to = new TestThrad();
//        to.start();

        Thread rt = new Thread(new TestRunable());
        Thread rt1 = new Thread(new TestRunable(),"t-1");

        rt.start();
        rt1.start();

        for(int i= 0 ; i<5 ; i++){
            System.out.println("伞兵一号准备就绪");
            System.out.println("我宣布");
            System.out.println("现在这里叫做卢本伟广场");
            System.out.println("伞兵一号准备就绪");
            System.out.println("我宣布");
            System.out.println("现在这里叫做卢本伟广场");
        }
    }
}

三、Thread类的有关方法

void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static currentThread(): 返回当前线程
static void yield()：线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
抛出InterruptedException异常
stop(): 强制线程生命期结束
boolean isAlive()：返回boolean，判断线程是否还活着
线程的优先级控制
MAX_PRIORITY（10）;
MIN _PRIORITY （1）;
NORM_PRIORITY （5）;
涉及的方法：
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级
线程创建时继承父线程的优先级，默认都是5，数值越高优先级越高。
但不是优先级越高就会先执行，这东西就是概率性的东西，优先级越高被执行的概率越高。
以下代码对上述方法都有实现。

public class Test1 {
	public static void main(String[] args) {
		TestRun run0 = new TestRun();
		TestRun run1 = new TestRun();
		
		Thread t0 = new Thread(run0);
		
		Thread t1 = new Thread(run1);
		
		t0.setName("线程t-0");//设置线程的名称
		t1.setName("线程t-1");//设置线程的名称
		
//		t0.setPriority(1);//设置线程的优先级
//		t1.setPriority(10);//设置线程的优先级
		
		t0.start();
		t1.start();
//		System.out.println(t0.getName());//如果在创建线程的时候没有指定名称，系统会给出默认名称，通过getName()获取线程名称
//		System.out.println(t1.getName());
		
		/**
		 * 线程的优先级，就是哪个线程有较大个概率被执行
		 * 优先级是用数组1-10表示，数字越大优先级越高，如果没有设置默认优先级是5
		 */
		
//		System.out.println("t0的优先级：" + t0.getPriority());//获取线程的优先级
		
		System.out.println("---------------1");
		System.out.println("---------------2");
		
		System.out.println(t1.isAlive());//判断当前的线程是否存活
		
		t1.stop();//强制线程生命期结束,强制停止此线程
		
		try {
			t0.join();//相当于在这块把t0的run的代码插入到这个位置执行
			/**
			 * 专业的说法
			 * 就是阻塞当前的main方法，先不执行System.out.println("---------------3");代码
			 * 先执行join进来的线程的代码
			 * join的线程执行完毕之后继续执行之前main方法阻塞的代码System.out.println("---------------3");
			 */
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		
		System.out.println("---------------3");
		
		System.out.println(t1.isAlive());
	}
}

class TestRun implements Runnable{
	int count = 0;
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + ":Runnable多线程运行的代码");
		for(int i = 0; i < 5; i++){
//			try {
//				Thread.sleep(1000);//当前线程睡眠1000毫秒
//				//相当于当前的这个循环每隔1000毫秒执行一次循环
//			} catch (InterruptedException e) {
//				e.printStackTrace();
//			}
			
//			if(i % 2 == 0){
//				Thread.yield();//线程让步
//			}
			
			count++;
			System.out.println(Thread.currentThread().getName() + ":这是Runnable多线程的逻辑代码:" + count);
		}
	}
	
}

四、线程的生命周期

JDK中用Thread.State枚举表示了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止

在这里插入图片描述

四、线程的同步

问题的提出
多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
关于synchronized关键字，锁住的东西是什么？个人认为它锁住的是一个对象。
1. 普通方法加Synchronized（同步锁），锁的当前方法对应的对象，当前的对象的所有加了同步锁的方法是共用一个同步锁。
2. 静态的方法加synchronized，对于所有的对象都是使用同一个一个锁。
3. 代码块synchronized(this)，所有当前的对象的synchronized(this)同步的的代码都是使用同一个锁，在不同方法有synchronized(this)代码块，只要它们对象是同一个，那么就是同一个锁。
4. synchronized(a),这个小括号中传入不同的对象就是不同的锁，若是一个对象就是一个同一个锁。
下面例子使用synchronized关键字实现线程线程同步

/**
*此代码逻辑是两个用户同时向同一个账户取钱，本来余额为3000，
*两个用户都要取2000，若是不加锁直接多线程取钱，必定会出现余额为-1000的情况
*所需需要加锁，使线程同步。
*/
public class Test2 {
	public static void main(String[] args) {
		//定义账户对象
		Acount a = new Acount();
		Acount a1 = new Acount();
		
		//多线程对象
		User u_weixin = new User(a, 2000);
		User u_zhifubao = new User(a, 2000);
		
		Thread weixin = new Thread(u_weixin,"微信");
		Thread zhifubao = new Thread(u_zhifubao,"支付宝");
		
		weixin.start();
		zhifubao.start();
	}
}

class Acount{
	public static int money = 3000;//全局变量，所有的操作共享这个变量
	
	/**
	 * 提款，判断账户钱够不够
	 * 多线程调用这个方法，就有问题，线程共享资源时，一个线程在执行这个方法没有完毕时，另一个线程又开始执行这个方法
	 * 解决思路：显然一个线程整体执行完这个方法，另一个线程再执行
	 * 通过synchronized同步锁来完成
	 * 可以直接在方法上加上synchronized关键字
	 * 在普通方法上加同步锁synchronized，锁的是整个对象，不是某一个方法
	 * 不同的对象就是不同的锁，普通方法加synchronized，线程使用不同的此方法的对象，还有共享资源的问题
	 * 
	 * 普通方法加同步锁，锁的当前方法对应的对象，当前的对象的所有加了同步锁的方法是共用一个同步锁
	 * @param m
	 */
	public synchronized void drawing(int m){
		String name = Thread.currentThread().getName();
		
		if(money < m){
			System.out.println(name + "操作，账户金额不足：" + money);
		}else{
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
			money = money - m;
			System.out.println(name + "操作，取款后的余额：" + money);
		}
		
	}
	
	public synchronized void drawing1(int m){
		String name = Thread.currentThread().getName();
		
		if(money < m){
			System.out.println(name + "操作，账户金额不足：" + money);
		}else{
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
			money = money - m;
			System.out.println(name + "操作，取款后的余额：" + money);
		}
		
	}
	
	/**
	 * 静态的方法加synchronized，对于所有的对象都是使用同一个一个锁
	 * @param m
	 */
	public static synchronized void drawing2(int m){
		String name = Thread.currentThread().getName();
		
		if(money < m){
			System.out.println(name + "操作，账户金额不足：" + money);
		}else{
			System.out.println(name + "操作，账户原有金额：" + money);
			System.out.println(name + "操作，取款金额：" + m);
			
			System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
			money = money - m;
			System.out.println(name + "操作，取款后的余额：" + money);
		}
		
	}
	
	/**
	 * 对代码块加入同步锁
	 * 代码块synchronized(this)，所有当前的对象的synchronized(this)同步的的代码都是使用同一个锁
	 * @param m
	 */
	public void drawing3(int m){
		synchronized(this){//表示当前的对象的代码块被加了synchronized同步锁
			//用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
			String name = Thread.currentThread().getName();
			
			if(money < m){
				System.out.println(name + "操作，账户金额不足：" + money);
			}else{
				System.out.println(name + "操作，账户原有金额：" + money);
				System.out.println(name + "操作，取款金额：" + m);
				
				System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
				money = money - m;
				System.out.println(name + "操作，取款后的余额：" + money);
			}
		}
	}
	
	public void drawing4(int m){
		synchronized(this){//表示当前的对象的代码块被加了synchronized同步锁
			//用this锁代码块是代表当前的对象，如果在其他方法中也有synchronized(this)的代码块使用的都是同一个同步锁
			String name = Thread.currentThread().getName();
			
			if(money < m){
				System.out.println(name + "操作，账户金额不足：" + money);
			}else{
				System.out.println(name + "操作，账户原有金额：" + money);
				System.out.println(name + "操作，取款金额：" + m);
				
				System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
				money = money - m;
				System.out.println(name + "操作，取款后的余额：" + money);
			}
		}
	}
	
	/**
	 * synchronized修饰代码块，想要根据不同的对象有不同的锁
	 * synchronized(a),这个小括号中传入不同的对象就是不同的锁
	 * @param m
	 */
	public void drawing5(int m,Acount a){
		synchronized(a){//表示通过方法的参数传递进来的对象的代码块被加了synchronized同步锁
			//不同的对象就有不同的同步锁
			String name = Thread.currentThread().getName();
			
			//如果是微信操作的，先不执行，等支付宝操作，支付宝操作完，微信再继续操作
			if(name.equals("微信")){
				try {
					a.wait();//当前的线程进入等待的阻塞状态
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			
			if(money < m){
				System.out.println(name + "操作，账户金额不足：" + money);
			}else{
				System.out.println(name + "操作，账户原有金额：" + money);
				System.out.println(name + "操作，取款金额：" + m);
				
				System.out.println(name + "操作，取款操作：原金额" + money + " - " + "取款金额" + m);
				money = money - m;
				System.out.println(name + "操作，取款后的余额：" + money);
			}
			
			if(name.equals("支付宝")){
				try {
					a.notify();//唤醒当前优先级最高的线程，进入就绪状态
//					a.notifyAll();//唤醒当前所有的线程，进入就绪状态
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}
} 

class User implements Runnable{
	Acount acount;
	int money;
	public User(Acount acount,int money){
		this.acount = acount;
		this.money = money;
	}
	@Override
	public void run() {
//		acount.drawing(money);
//		if(Thread.currentThread().getName().equals("微信")){
			acount.drawing(money);
//			acount.drawing3(money);
//		}else{
			acount.drawing1(money);
//			acount.drawing4(money);
//		}
//		acount.drawing2(money);//调用类的静态方法
		
//		acount.drawing3(money);
		
		acount.drawing5(money, acount);
	}
	
}

五、线程的死锁问题

死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
解决方法
专门的算法、原则，比如加锁顺序一致
尽量减少同步资源的定义，尽量避免锁未释放的场景

六、线程间通信

线程间通信不是说线程进行收发信息交流的意思，线程间通信是线程间有相应的逻辑，能让各个线程能按照一定逻辑有序的执行，比如自己暂停让别人先执行，等等。
线程间的通信运用的3个方法wait() 与 notify() 和 notifyAll()。

wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常，当然也可以不放在synchronized，不过要捕获异常。以上代码drawing5(int m,Acount a)中有体现。

七、经典线程同步—生产者/消费者问题


/**
 * 生产者与消费者
 * @author lby
 *
 */
public class Test3 {
	public static void main(String[] args) {
		Clerk c = new Clerk();
		//消费时不生产，生产时不消费
		
		//生产者
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (c) {
					while(true){//无限循环代表无限的生产次数
						if(c.productNum == 0){//产品数为0，开始生产
							System.out.println("产品数为0，开始生产");
							while(c.productNum < 4){
								c.productNum++;//增加产品
								System.out.println("库存：" + c.productNum);
							}
							System.out.println("产品数为" + c.productNum + "，结束生产");
							
							c.notify();//唤醒消费者线程
						}else{
							try {
								c.wait();//生产者线程等待
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
				}
			}
		}, "生产者").start();
		
		//消费者
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized (c) {
					while(true){//无限循环代表无限的消费次数
						if(c.productNum == 4){//产品数为4，开始消费
							System.out.println("产品数为4，开始消费");
							while(c.productNum > 0){
								c.productNum--;//消费产品
								System.out.println("库存：" + c.productNum);
							}
							System.out.println("产品数为" + c.productNum + "，结束消费");
							
							c.notify();//唤醒生产者线程
						}else{
							try {
								c.wait();//消费者线程等待
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
				}
			}
		}, "消费者").start();
		
	}
}


class Clerk{
	public static int productNum = 0;
}

小小卡尔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE--重新学习_查漏补缺(16)--多线程创建和启动_Thread类的有关方法_线程的生命周期_线程的同步_线程的死锁问题_线程间通信_经典线程同步---生产者/消费者问题

文章目录一、多线程二、多线的创建和启动三、Thread类的有关方法一、多线程形象理解====多线程相当进程的支流，各走各的，假设在进程上跑的代码是主程序，当其中的第三行代码是开启线程的，那么开启线程之后，线程运行的代码就和主程序并行（即它们之间不相干了）二、多线的创建和启动Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类和java.util.concu...
复制链接

扫一扫