毕25-第六天(day11)-多线程

Java 专栏收录该内容
17 篇文章 0 订阅
  • 多线程创建及运行

进程是一个正在执行的程序,每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。

线程就是进程中的一个独立的控制单元,线程在控制着进程的执行。

一个进程中至少有一个线程。

JavaVM启动的时候会有一个进程java.exe,该进程中至少有一个线程负责Java程序的执行,而且这个线程运行的代码存在于main方法中,该线程称之为主线程。

扩展:其实更细节的说,jvm启动的不止一个线程,还有负责垃圾回收机制的线程。

Java已经提供了对线程这类事物的描述,即Thread类。

创建线程的方式:1、定义类继承Thread类;2、覆盖Thread类中的run方法(将自定义代码存储在run方法中,让线程运行);3、调用线程的start方法,该方法有两个作用:启动线程和调用run方法。如下面的创建线程的例子:

class Demo extends Thread{
	public void run() {
        for(int x=0; x<60; x++)
		    System.out.println("demo run.."+x);
	}
}

public class Main{
	public static void main(String[] args) {
		Demo d = new Demo();
		d.start();
        for(int x=0; x<60; x++)
            System.out.println("main run.."+x);
	}
}

观察上面的例子会发现每次运行结果都不相同,因为多个线程都获取CPU的执行使用权,CPU执行到谁,谁就运行。需要明确一点:在某一时刻,只能有一个程序在运行(多核CPU除外);CPU在做着快速的切换以达到看上去是同时运行的效果。可以把多线程的运行看成是各个线程互相抢夺CPU的执行权,这就是多线程的一个特点:随机性;谁抢到谁执行,执行多少时间由CPU说了算。

Thread类用于描述线程,该类就定义了一个功能,用于存储线程要运行的代码,该存储功能就是run方法。

如果将上面代码示例中的d.start();修改为d.run();,则得到的结果是唯一的,先将demo run运行完,再运行main run,这是因为使用d.run()只是调用了Demo类中的run方法,线程创建了但是并没有启动,还是处于主线程这一个线程中,只有使用d.start()才是将新创建的线程启动,并执行新线程的run方法。

  • 获取线程对象及名称

线程都有自己默认的名称:Thread-编号;该编号从0开始。

class Test extends Thread{
	Test(String name){
		super(name);	//Thread类中已经定义过了给线程命名的函数。
	}
	public void run() {
        for(int x=0; x<60; x++) {
            System.out.println(this.getName()+"run.."+x);
            //System.out.println(Thread.currentThread().getName()+"run.."+x);    //和上面的语句是一种意思。
        }
	}
}

public class Main{
	public static void main(String[] args) {
		Test t1 = new Test("one");
		Test t2 = new Test("two");
		t1.start();
		t2.start();
        for(int x=0; x<60; x++) {
            System.out.println("main run.."+x);
        }
	}
}

static Thread currentThread():获取当前线程对象。

getName():获取线程名称。

设置线程名称:setName()或者构造函数

  • 卖票小程序

下面利用多线程可以实现多窗口同时卖票:

class Ticket extends Thread{
	private static int tick = 100;
	public void run() {
        while(true) {
        	if(tick>0) {
        		System.out.println(currentThread().getName()+".sale:"+tick--);
        	}
        }
	}
}

public class Main{
	public static void main(String[] args) {
		Ticket t1 = new Ticket();
		Ticket t2 = new Ticket();
		Ticket t3 = new Ticket();
		Ticket t4 = new Ticket();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

对于上面的程序,如果tick没有使用static修饰的话,就会出现四个线程中,每个线程都有一个自己的tick,总共会卖出400张票,每一张票都会有四个窗口卖出相同的票。

但是如果使用static修饰的话,该变量生存周期太长了,所以下面介绍另一种线程创建方式:实现Runnable接口。

class Ticket implements Runnable{
	private int tick = 100;
	public void run() {
        while(true) {
        	if(tick>0) {
        		System.out.println(Thread.currentThread().getName()+".sale:"+tick--);
        	}
        }
	}
}

public class Main{
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

创建线程的第二种方式:实现Runnable接口:

步骤:

1、定义类实现Runnable接口;

2、覆盖Runnable接口中的run方法,将线程要运行的代码存放在该run方法中;

3、通过Thread类建立线程对象;

4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数;为什么要将Runnable接口的子类对象传递给Thread的构造函数,这是因为自定义的run方法所属的对象是Runnable接口的子类对象,所以要让线程去执行指定对象的run方法,就必须明确该run方法所属对象。

5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

实现Runnable接口方式和继承Thread方式有什么区别呢?

 如上图,因为Java中继承只能使用单继承,但是如果一个类Student本来已经继承了Person类,这时该类要实现多线程却不能再继承Thread,这时只能实现Runnable接口。

所以实现Runnable接口方式的好处是避免了单继承的局限性;在创建线程时,建议使用实现方式。

两种方式的区别:

继承Thread方式:线程代码存放在Thread子类run方法中;

实现Runnable方式:线程代码存放在接口的子类的run方法中。

  • 多线程的安全问题

对于上面的卖票代码可能会出现问题,使用sleep语句,使其表现更明显:

class Ticket implements Runnable{
	private int tick = 100;
	public void run() {
        while(true) {
        	if(tick>0) {
                    try{Thread.sleep(10);
                    }catch(Exception e){}
        	    System.out.println(Thread.currentThread().getName()+".sale:"+tick--);
        	}
        }
	}
}

public class Main{
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

加入了sleep语句时,等同于会出现这样一种情况:创建好了t1、t2、t3、t4四个线程,最后还剩一张票的时候,这时t1判断tick>0,但是之后卡住了,随后t2、t3、t4依次判断符合tick>0,均进入if语句内,这时四个线程再依次执行,便可能出现票号为负的情况。

通过分析发现打印出了0,-1,-2等错票,多线程的运行出现了安全问题。

问题的原因:

当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完时,另一个线程参与进来执行,导致共享数据的错误。

解决办法:

对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。

Java对于多线程的安全问题提供了专业的解决方式,就是同步代码块:

synchronized(对象){
    //需要被同步的代码;
}

加入同步代码块之后,程序如下:

class Ticket implements Runnable{
	private int tick = 100;
	Object obj = new Object();
	public void run() {
        while(true) {
        	synchronized(obj) {    //同步代码块
	        	if(tick>0) {
	                    try{Thread.sleep(10);
	                    }catch(Exception e){}
	        	    System.out.println(Thread.currentThread().getName()+".sale:"+tick--);
	        	}
        	}
        }
	}
}

public class Main{
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

对象如同锁,持有锁的线程可以在同步代码块中执行,没有持有锁的线程即使获得CPU的执行权,也进不去,因为没有获取锁。

同步的前提:

1、必须要有两个或两个以上的线程;

2、必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。好处是解决了多线程的安全问题;弊端是多个线程需要判断锁,较为消耗资源。

  • 同步函数

下面有一个银行存钱的例子:

/*
需求:银行有一个金库,有两个储户分别存300元,每次存100,存三次。
*/
class Bank{
	private int sum;
	public void add(int n) {
		sum = sum+n;
		System.out.println("sum="+sum);
	}
}

class Save implements Runnable{
	private Bank b = new Bank();
	public void run() {
		for(int x=0; x<3; x++) {
			b.add(100);
		}
	}
}

public class Main{
	public static void main(String[] args) {
		Save s = new Save();
		Thread t1 = new Thread(s);
		Thread t2 = new Thread(s);
		t1.start();
		t2.start();
	}
}

会输出:

sum=100
sum=200
sum=300
sum=400
sum=500
sum=600

下面判断上面函数是否有问题,首先看如何找问题:

1、明确那些代码是多线程代码;

2、明确共享数据;

3、明确多线程运行代码中哪些语句是操作共享数据的。

在上述代码中,将代码改成下面的样子就会出现存钱有问题的状态:

class Bank{
	private int sum;
	public void add(int n) {
		sum = sum+n;
        try{Thread.sleep(10);}catch{Exception e}
		System.out.println("sum="+sum);
	}
}

这时会输出这样的情况:

sum=200
sum=200
sum=400
sum=400
sum=600
sum=600

这是因为经过sleep10ms之后,两个线程同时输出一个共享数据的值,会出现错误存钱数。这时需要将操作共享数据的代码块进行上锁:

class Bank{
	private int sum;
    Object obj = new Object();
	public void add(int n) {
        synchronized(obj){
		    sum = sum+n;
            try{Thread.sleep(10);}catch{Exception e}
		    System.out.println("sum="+sum);
        }
	}
}

进行上锁操作之后就能输出正常存钱值了。

除了上面一种同步代码块的上锁方式,还有一种同步函数的上锁方式,就是在需要同步的函数上加上synchronized关键字:

class Bank{
	private int sum;
	public synchronized void add(int n) {
		    sum = sum+n;
            try{Thread.sleep(10);}catch{Exception e}
		    System.out.println("sum="+sum);
	}
}
  • 同步函数的锁是this

 卖票例子的同步函数版本:

class Ticket implements Runnable{
	private int tick = 100;
	public void run() {		//不可以给run方法上锁,这是因为一旦给润、上锁了,这时第一个线程进来了,后面的线程都进不来了
        while(true) {
        	show();
        }
	}
	public synchronized void show() {
		if(tick>0) {
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+".sale:"+tick--);
		}
	}
}

public class Main{
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

从上面可以看到,run方法中调用的是show方法,是给show方法上锁的。而调用show方法的是this对象,下面验证调用对象确实是this,把卖票的例子搞成两个线程,对两个线程分别使用不同的上锁方式,一个使用同步代码块,一个使用同步函数。

class Ticket implements Runnable{
	private int tick = 100;
	Object obj = new Object();
	boolean flag = true;
	public void run() {
		if(flag) {
	        while(true) {
	        	synchronized(obj) {
		        	if(tick>0) {
		                try{Thread.sleep(10);}catch(Exception e){}
		                System.out.println(Thread.currentThread().getName()+".code:"+tick--);
		    		}
	        	}
	        }
		}else
			while(true)
				show();
	}
	public synchronized void show() {
		if(tick>0) {
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+".show:"+tick--);
		}
	}
}

public class Main{
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try {Thread.sleep(10);}catch(Exception e){}		//需要进行休眠一下,防止主线程运行太快,从而使两个新建线程flag都变为false。
		t.flag = false;
		t2.start();
	}
}

在上面的例子中最后可能会输出一个0号票,这是一个错误票,错误原因是两个新建线程使用的不是同一个锁,这时将obj换为this,则会正确输出,这也印证了同步函数的锁是this。

  • 静态同步函数的锁是Class对象

如果同步函数被静态修饰后,使用的锁是什么呢?通过验证可以使用this会出现错误,所以不是this,因为静态方法也不可以定义this;静态成员进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象:类名.class,该对象的类型时Class:

class Ticket implements Runnable{
	private static int tick = 100;
	boolean flag = true;
	public void run() {
		if(flag) {
	        while(true) {
	        	synchronized(Ticket.class) {
		        	if(tick>0) {
		                try{Thread.sleep(10);}catch(Exception e){}
		                System.out.println(Thread.currentThread().getName()+".code:"+tick--);
		    		}
	        	}
	        }
		}else
			while(true)
				show();
	}
	public static synchronized void show() {
		if(tick>0) {
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+".show:"+tick--);
		}
	}
}

public class Main{
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try {Thread.sleep(10);}catch(Exception e){}		//需要进行休眠一下,防止主线程运行太快,从而使两个新建线程flag都变为false。
		t.flag = false;
		t2.start();
	}
}

所以静态的同步方法使用的锁是该方法所在类的字节码文件对象:类名.class。

单例设计模式中的懒汉式需要再看看,可见博客:https://blog.csdn.net/sleepingposture/article/details/105958153

 

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 打赏
    打赏
  • 扫一扫,分享海报

©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页

打赏作者

sleepingposture

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值