9.1 相关概念(了解)
9.1.1 线程与进程
-
程序:为了完成某个任务和功能,选择一种编程语言编写的一组指令的集合。
-
软件:1个或多个应用程序+相关的素材和资源文件等构成一个软件系统。
-
进程:是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间,进程也是程序的一次执行过程,是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程。
-
线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。
简而言之:一个软件中至少有一个应用程序,应用程序的一次运行就是一个进程,一个进程中至少有一个线程。
-
面试题:
-
进程是操作系统调度和分配资源的最小单位,线程是CPU调度的最小单位。
-
不同的进程之间是不共享内存的。进程之间的数据交换和通信的成本是很高。
-
不同的线程是共享同一个进程的内存的。当然不同的线程也有自己独立的内存空间。
-
对于方法区,堆中的同一个对象的内存,线程之间是可以共享的,但是栈的局部变量永远是独立的。另外进程之前切换的复杂度要远远高于线程之间的切换调度。
-
9.1.2 查看进程和线程
我们可以再电脑底部任务栏,右键----->打开任务管理器,可以查看当前任务的进程:
1、每个应用程序的运行都是一个进程
2、一个应用程序的多次运行,就是多个进程
3、一个进程中包含多个线程
9.1.3 并发与并行
-
并行(parallel):指两个或多个事件在同一时刻发生(同时发生)。指在同一时刻,有多条指令在多个处理器上同时执行。
-
并发(concurrency):指两个或多个事件在同一个时间段内发生。指在同一个时刻只能有一条指令执行,但多个进程的指令被快速轮换执行,使得在宏观上具有多个进程同时执行的效果。
在操作系统中,启动了多个程序,并发指的是在一段时间内宏观上有多个程序同时运行,这在单 CPU 系统中,每一时刻只能有一个程序执行,即微观上这些程序是分时的交替运行,只不过是给人的感觉是同时运行,那是因为分时交替运行的时间是非常短的。
而在多个 CPU 系统中,则这些可以并发执行的程序便可以分配到多个处理器上(CPU),实现多任务并行执行,即利用每个处理器来处理一个可以并发执行的程序,这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU,便是多核处理器,核越多,并行处理的程序越多,能大大的提高电脑运行的效率。
假设你需要洗衣服和做饭(两个任务)
-
并行 : 将洗衣盆拿到厨房,左手炒菜,右手洗衣服。
-
并发 : 一会洗衣,一会做饭,但疾如闪电切换。
注意:单核处理器的计算机肯定是不能并行的处理多个任务的,只能是多个任务在单个CPU上并发运行。同理,线程也是一样的,从宏观角度上理解线程是并行运行的,但是从微观角度上分析却是串行运行的,即一个线程一个线程的去运行,当系统只有一个CPU时,线程会以某种顺序执行多个线程,我们把这种情况称之为线程调度。
单核CPU:只能并发
多核CPU:并行+并发
9.1.4 线程调度
-
分时调度
所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。
-
抢占式调度
优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为抢占式调度。
-
抢占式调度详解
大部分操作系统都支持多进程并发运行,现在的操作系统几乎都支持同时运行多个程序。比如:现在我们上课一边使用编辑器,一边使用录屏软件,同时还开着画图板,dos窗口等软件。此时,这些程序是在同时运行,”感觉这些软件好像在同一时刻运行着“。
实际上,CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言,某个时刻,只能执行一个线程,而 CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是在同一时刻运行。 其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率,让CPU的使用率更高。
-
9.2 另行创建和启动线程
当运行Java程序时,其实已经有一个线程了,那就是main线程。
那么如何创建和启动main线程以外的线程呢?
9.2.1 继承Thread类
Java使用java.lang.Thread
类代表线程,所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务,实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下:
-
定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
-
创建Thread子类的实例,即创建了线程对象
-
调用线程对象的start()方法来启动该线程
代码如下:
自定义线程类:
package com.haogu.thread; public class MyThread extends Thread { //定义指定线程名称的构造方法 public MyThread(String name) { //调用父类的String参数的构造方法,指定线程的名称 super(name); } /** * 重写run方法,完成该线程执行的逻辑 */ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(getName()+":正在执行!"+i); } } }
测试类:
package com.haogu.thread; public class TestMyThread { public static void main(String[] args) { //创建自定义线程对象 MyThread mt = new MyThread("新的线程!"); //开启新线程 mt.start(); //在主方法中执行for循环 for (int i = 0; i < 10; i++) { System.out.println("main线程!"+i); } } }
9.2.2 实现Runnable接口
Java有单继承的限制,当我们无法继承Thread类时,那么该如何做呢?在核心类库中提供了Runnable接口,我们可以实现Runnable接口,重写run()方法,然后再通过Thread类的对象代理启动和执行我们的线程体run()方法
步骤如下:
-
定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
-
创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正 的线程对象。
-
调用线程对象的start()方法来启动线程。 代码如下:
自定义线程类:
package com.haogu.thread; public class MyRunnable implements Runnable { @Override public void run() { for (int i = 0; i < 20; i++) { System.out.println(Thread.currentThread().getName() + " " + i); } } }
测试类:
package com.haogu.thread; public class TestMyRunnable { public static void main(String[] args) { //创建自定义类对象 线程任务对象 MyRunnable mr = new MyRunnable(); //创建线程对象 Thread t = new Thread(mr, "长江"); t.start(); for (int i = 0; i < 20; i++) { System.out.println("黄河 " + i); } } }
通过实现Runnable接口,使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程 代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候,需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象,然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此,不管是继承Thread类还是实现 Runnable接口来实现多线程,最终还是通过Thread的对象的API来控制线程的,熟悉Thread类的API是进行多线程编程的基础。
tips:Runnable对象仅仅作为Thread对象的target,Runnable实现类里包含的run()方法仅作为线程执行体。 而实际的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run()方法。
9.2.3 使用匿名内部类对象来实现线程的创建和启动
new Thread("新的线程!"){ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(getName()+":正在执行!"+i); } } }.start();
new Thread(new Runnable(){ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName()+":" + i); } } }).start();
9.3 Thread类
9.3.1 构造方法
-
public Thread() :分配一个新的线程对象。
-
public Thread(String name) :分配一个指定名字的新的线程对象。
-
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
-
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
9.3.2 常用方法系列1
-
public void run() :此线程要执行的任务在此处定义代码。
-
public String getName() :获取当前线程名称。
-
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
-
public final int getPriority() :返回线程优先级
-
public final void setPriority(int newPriority) :改变线程的优先级
-
每个线程都有一定的优先级,优先级高的线程将获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。Thread类提供了setPriority(int newPriority)和getPriority()方法类设置和获取线程的优先级,其中setPriority方法需要一个整数,并且范围在[1,10]之间,通常推荐设置Thread类的三个优先级常量:
-
MAX_PRIORITY(10):最高优先级
-
MIN _PRIORITY (1):最低优先级
-
NORM_PRIORITY (5):普通优先级,默认情况下main线程具有普通优先级。
-
示例:
-
获取main线程对象的名称和优先级。
-
声明一个匿名内部类继承Thread类,重写run方法,在run方法中获取线程名称和优先级。设置该线程优先级为最高优先级并启动该线程。
public static void main(String[] args) { Thread t = new Thread(){ public void run(){ System.out.println(getName() + "的优先级:" + getPriority()); } }; t.setPriority(Thread.MAX_PRIORITY); t.start(); System.out.println(Thread.currentThread().getName() +"的优先级:" + Thread.currentThread().getPriority()); }
9.3.3 常用方法系列2
-
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
-
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
-
public static void yield():yield只是让当前线程暂停一下,让系统的线程调度器重新调度一次,希望优先级与当前线程相同或更高的其他线程能够获得执行机会,但是这个不能保证,完全有可能的情况是,当某个线程调用了yield方法暂停之后,线程调度器又将其调度出来重新执行。
-
void join() :等待该线程终止。
void join(long millis) :等待该线程终止的时间最长为 millis 毫秒。如果millis时间到,将不再等待。
void join(long millis, int nanos) :等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
-
public final boolean isAlive():测试线程是否处于活动状态。如果线程已经启动且尚未终止,则为活动状态
案例:
-
声明一个匿名内部类继承Thread类,重写run方法,实现打印[1,100]之间的偶数,要求每隔1秒打印1个偶数。
-
声明一个匿名内部类继承Thread类,重写run方法,实现打印[1,100]之间的奇数,
-
当打印到5时,让奇数线程暂停一下,再继续。
-
当打印到5时,让奇数线程停下来,让偶数线程执行完再打印。
-
当打印到5时,让奇数线程停下来,让偶数线程先执行10秒完再打印。
-
package com.haogu.api; public class TestThreadStateChange { public static void main(String[] args) { Thread te = new Thread() { @Override public void run() { for (int i = 2; i <= 100; i += 2) { System.out.println("偶数线程:" + i); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } }; te.start(); Thread to = new Thread() { @Override public void run() { for (int i = 1; i <= 100; i += 2) { System.out.println("奇数线程:" + i); if (i == 5) { // Thread.yield(); try { te.join(); } catch (InterruptedException e) { e.printStackTrace(); } } } } }; to.start(); } }
9.3.4 如何让线程提前结束
一个线程如何让另一个线程提前结束呢?
线程的死亡有两种:
自然死亡:当一个线程的run方法执行完,线程自然会停止。
意外死亡:当一个线程遇到未捕获处理的异常,也会挂掉。
我们肯定希望是让线程自然死亡更好。
-
public final void stop():强迫线程停止执行。 该方法具有固有的不安全性,已经标记为@Deprecated(已过时、已废弃)不建议再使用,那么我们就需要通过其他方式来停止线程了,其中一种方式是使用变量的值的变化来控制线程是否结束。
-
标记法
案例:
声明一个PrintEvenThread线程类,继承Thread类,重写run方法,实现打印[1,100]之间的偶数,要求每隔1毫秒打印1个偶数。
声明一个PrintOddThread线程类,继承Thread类,重写run方法,实现打印[1,100]之间的奇数。
在main线程中:
(1)创建两个线程对象,并启动两个线程
(2)当打印奇数的线程结束了,让偶数的线程也停下来,就算偶数线程没有全部打印完[1,100]之间的偶数。
package com.haogu.api; public class PrintEvenThread extends Thread{ private boolean flag = true; @Override public void run() { for (int i = 2; i <= 100 && flag; i += 2) { System.out.println("偶数线程:" + i); try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } } public void setFlag(boolean flag) { this.flag = flag; } }
package com.haogu.api; public class PrintOddThread extends Thread { @Override public void run() { for (int i = 1; i <= 100; i += 2) { System.out.println("奇数线程:" + i); } } }
package com.haogu.api; public class TestThreadStop { public static void main(String[] args) { PrintEvenThread pe = new PrintEvenThread(); PrintOddThread po = new PrintOddThread(); pe.start(); po.start(); try { po.join(); } catch (InterruptedException e) { e.printStackTrace(); } pe.setFlag(false); } }
9.3.5 守护线程(了解)
有一种线程,它是在后台运行的,它的任务是为其他线程提供服务的,这种线程被称为“守护线程”。JVM的垃圾回收线程就是典型的守护线程。
守护线程有个特点,就是如果所有非守护线程都死亡,那么守护线程自动死亡。
调用setDaemon(true)方法可将指定线程设置为守护线程。必须在线程启动之前设置,否则会报IllegalThreadStateException异常。
调用isDaemon()可以判断线程是否是守护线程。
public class TestThread { public static void main(String[] args) { MyDaemon m = new MyDaemon(); m.setDaemon(true); m.start(); for (int i = 1; i <= 100; i++) { System.out.println("main:" + i); } } } class MyDaemon extends Thread { public void run() { while (true) { System.out.println("我一直守护者你..."); try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } } }
9.4 线程安全
当我们使用多个线程访问同一资源(可以是同一个变量、同一个文件、同一条记录等)的时候,若多个线程只有读操作,那么不会发生线程安全问题,但是如果多个线程中对资源有读和写的操作,就容易出现线程安全问题。
我们通过一个案例,演示线程的安全问题: 电影院要卖票,我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”,本次电影的座位共100个 (本场电影只能卖100张票)。 我们来模拟电影院的售票窗口,实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)
9.4.1 同一个资源问题和线程安全问题
1、局部变量不能共享
示例代码:
package com.haogu.unsafe; public class SaleTicketDemo1 { public static void main(String[] args) { Window w1 = new Window(); Window w2 = new Window(); Window w3 = new Window(); w1.start(); w2.start(); w3.start(); } } class Window extends Thread { public void run() { int total = 100; while (total > 0) { System.out.println(getName() + "卖出一张票,剩余:" + --total); } } }
结果:发现卖出300张票。
问题:局部变量是每次调用方法都是独立的,那么每个线程的run()的total是独立的,不是共享数据。
2、不同对象的实例变量不共享
package com.haogu.unsafe; public class SaleTicketDemo2 { public static void main(String[] args) { TicketSale t1 = new TicketSale(); TicketSale t2 = new TicketSale(); TicketSale t3 = new TicketSale(); t1.start(); t2.start(); t3.start(); } } class TicketSale extends Thread { private int total = 100; public void run() { while (total > 0) { System.out.println(getName() + "卖出一张票,剩余:" + --total); } } }
结果:发现卖出300张票。
问题:不同的实例对象的实例变量是独立的。
3、静态变量是共享的
示例代码:
package com.haogu.unsafe; public class SaleTicketDemo3 { public static void main(String[] args) { TicketSaleThread t1 = new TicketSaleThread(); TicketSaleThread t2 = new TicketSaleThread(); TicketSaleThread t3 = new TicketSaleThread(); t1.start(); t2.start(); t3.start(); } } class TicketSaleThread extends Thread{ private static int total = 100; public void run(){ while(total>0) { try { Thread.sleep(10);//加入这个,使得问题暴露的更明显 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(getName() + "卖出一张票,剩余:" + --total); } } }
运行结果:
Thread-1卖出一张票,剩余:99 Thread-2卖出一张票,剩余:98 Thread-0卖出一张票,剩余:99 Thread-2卖出一张票,剩余:96 Thread-0卖出一张票,剩余:95 Thread-1卖出一张票,剩余:97 Thread-1卖出一张票,剩余:94 Thread-2卖出一张票,剩余:92 Thread-0卖出一张票,剩余:93 Thread-1卖出一张票,剩余:91 Thread-2卖出一张票,剩余:89 Thread-0卖出一张票,剩余:90 Thread-0卖出一张票,剩余:87 Thread-1卖出一张票,剩余:86 Thread-2卖出一张票,剩余:88 Thread-2卖出一张票,剩余:85 Thread-0卖出一张票,剩余:85 Thread-1卖出一张票,剩余:84 Thread-1卖出一张票,剩余:83 Thread-0卖出一张票,剩余:82 Thread-2卖出一张票,剩余:81 Thread-1卖出一张票,剩余:80 Thread-0卖出一张票,剩余:78 Thread-2卖出一张票,剩余:79 Thread-1卖出一张票,剩余:77 Thread-2卖出一张票,剩余:77 Thread-0卖出一张票,剩余:77 Thread-1卖出一张票,剩余:76 Thread-0卖出一张票,剩余:74 Thread-2卖出一张票,剩余:75 Thread-1卖出一张票,剩余:73 Thread-0卖出一张票,剩余:71 Thread-2卖出一张票,剩余:72 Thread-2卖出一张票,剩余:70 Thread-0卖出一张票,剩余:69 Thread-1卖出一张票,剩余:68 Thread-2卖出一张票,剩余:66 Thread-1卖出一张票,剩余:67 Thread-0卖出一张票,剩余:65 Thread-1卖出一张票,剩余:64 Thread-2卖出一张票,剩余:62 Thread-0卖出一张票,剩余:63 Thread-0卖出一张票,剩余:60 Thread-1卖出一张票,剩余:59 Thread-2卖出一张票,剩余:61 Thread-1卖出一张票,剩余:58 Thread-0卖出一张票,剩余:56 Thread-2卖出一张票,剩余:57 Thread-2卖出一张票,剩余:55 Thread-0卖出一张票,剩余:54 Thread-1卖出一张票,剩余:53 Thread-2卖出一张票,剩余:52 Thread-0卖出一张票,剩余:50 Thread-1卖出一张票,剩余:51 Thread-2卖出一张票,剩余:49 Thread-1卖出一张票,剩余:48 Thread-0卖出一张票,剩余:48 Thread-2卖出一张票,剩余:47 Thread-1卖出一张票,剩余:47 Thread-0卖出一张票,剩余:46 Thread-2卖出一张票,剩余:45 Thread-1卖出一张票,剩余:43 Thread-0卖出一张票,剩余:44 Thread-1卖出一张票,剩余:42 Thread-0卖出一张票,剩余:40 Thread-2卖出一张票,剩余:41 Thread-1卖出一张票,剩余:39 Thread-2卖出一张票,剩余:38 Thread-0卖出一张票,剩余:37 Thread-2卖出一张票,剩余:36 Thread-0卖出一张票,剩余:34 Thread-1卖出一张票,剩余:35 Thread-2卖出一张票,剩余:33 Thread-1卖出一张票,剩余:31 Thread-0卖出一张票,剩余:32 Thread-1卖出一张票,剩余:29 Thread-2卖出一张票,剩余:30 Thread-0卖出一张票,剩余:30 Thread-2卖出一张票,剩余:28 Thread-1卖出一张票,剩余:27 Thread-0卖出一张票,剩余:26 Thread-2卖出一张票,剩余:25 Thread-0卖出一张票,剩余:24 Thread-1卖出一张票,剩余:23 Thread-2卖出一张票,剩余:21 Thread-0卖出一张票,剩余:20 Thread-1卖出一张票,剩余:22 Thread-2卖出一张票,剩余:18 Thread-1卖出一张票,剩余:19 Thread-0卖出一张票,剩余:18 Thread-2卖出一张票,剩余:17 Thread-1卖出一张票,剩余:17 Thread-0卖出一张票,剩余:16 Thread-1卖出一张票,剩余:14 Thread-2卖出一张票,剩余:15 Thread-0卖出一张票,剩余:13 Thread-2卖出一张票,剩余:12 Thread-0卖出一张票,剩余:10 Thread-1卖出一张票,剩余:11 Thread-1卖出一张票,剩余:9 Thread-2卖出一张票,剩余:8 Thread-0卖出一张票,剩余:7 Thread-0卖出一张票,剩余:5 Thread-1卖出一张票,剩余:4 Thread-2卖出一张票,剩余:6 Thread-2卖出一张票,剩余:3 Thread-0卖出一张票,剩余:2 Thread-1卖出一张票,剩余:1 Thread-1卖出一张票,剩余:0 Thread-2卖出一张票,剩余:-1 Thread-0卖出一张票,剩余:-2
结果:发现卖出近100张票。
问题(1):但是有重复票或负数票问题。
原因:线程安全问题
问题(2):如果要考虑有两场电影,各卖100张票等
原因:TicketThread类的静态变量,是所有TicketThread类的对象共享
4、同一个对象的实例变量共享
示例代码:多个Thread线程使用同一个Runnable对象
package com.haogu.safe; package com.haogu.unsafe; public class SaleTicketDemo4 { public static void main(String[] args) { TicketSaleRunnable tr = new TicketSaleRunnable(); Thread t1 = new Thread(tr, "窗口一"); Thread t2 = new Thread(tr, "窗口二"); Thread t3 = new Thread(tr, "窗口三"); t1.start(); t2.start(); t3.start(); } } class TicketSaleRunnable implements Runnable { private int total = 100; public void run() { while (total > 0) { try { Thread.sleep(10);//加入这个,使得问题暴露的更明显 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total); } } }
结果:发现卖出近100张票。
问题:但是有重复票或负数票问题。
原因:线程安全问题
5、抽取资源类,共享同一个资源对象
示例代码:
package com.haogu.unsafe; public class SaleTicketDemo5 { public static void main(String[] args) { //2、创建资源对象 Ticket ticket = new Ticket(); //3、启动多个线程操作资源类的对象 Thread t1 = new Thread("窗口一") { public void run() { while (true) { ticket.sale(); } } }; Thread t2 = new Thread("窗口二") { public void run() { while (true) { ticket.sale(); } } }; Thread t3 = new Thread(new Runnable() { public void run() { ticket.sale(); } }, "窗口三"); t1.start(); t2.start(); t3.start(); } } //1、编写资源类 class Ticket { private int total = 100; public void sale() { if (total > 0) { try { Thread.sleep(10);//加入这个,使得问题暴露的更明显 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total); } else { throw new RuntimeException("没有票了"); } } public int getTotal() { return total; } }
结果:发现卖出近100张票。
问题:但是有重复票或负数票问题。
原因:线程安全问题
9.4.2 尝试解决线程安全问题
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题,Java中提供了同步机制 (synchronized)来解决。
根据案例简述:
窗口1线程进入操作的时候,窗口2和窗口3线程只能在外等着,窗口1操作结束,窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候,其他线程不能修改该资源,等待修改完毕同步之后,才能去抢夺CPU资源,完成对应的操作,保证了数据的同步性,解决了线程不安全的现象。
为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。
1、同步机制的原理
同步解决线程安全的原理:
同步机制的原理,其实就相当于给某段代码加“锁”,任何线程想要执行这段代码,都要先获得“锁”,我们称为它同步锁。因为Java对象在堆中的数据分为分为对象头、实例变量、空白的填充。而对象头中包含:
-
Mark Word:记录了和当前对象有关的GC、锁标记等信息。
-
指向类的指针:每一个对象需要记录它是由哪个类创建出来的。
-
数组长度(只有数组对象才有)
哪个线程获得了“同步锁”对象之后,”同步锁“对象就会记录这个线程的ID,这样其他线程就只能等待了,除非这个线程”释放“了锁对象,其他线程才能重新获得/占用”同步锁“对象。
2、同步代码块和同步方法
同步方法:synchronized 关键字直接修饰方法,表示同一时刻只有一个线程能进入这个方法,其他线程在外面等着。
public synchronized void method(){ 可能会产生线程安全问题的代码 }
同步代码块:synchronized 关键字可以用于某个区块前面,表示只对这个区块的资源实行互斥访问。 格式:
synchronized(同步锁){ 需要同步操作的代码 }
3、同步锁对象的选择
同步锁对象可以是任意类型,但是必须保证竞争“同一个共享资源”的多个线程必须使用同一个“同步锁对象”。
对于同步代码块来说,同步锁对象是由程序员手动指定的,但是对于同步方法来说,同步锁对象只能是默认的,
-
静态方法:当前类的Class对象
-
非静态方法:this
4、同步代码的范围选择
锁的范围太小:不能解决安全问题
锁的范围太大:因为一旦某个线程抢到锁,其他线程就只能等待,所以范围太大,效率会降低,不能合理利用CPU资源。
5、代码演示
示例一:静态方法加锁
package com.haogu.safe; public class SaleTicketDemo3 { public static void main(String[] args) { TicketSaleThread t1 = new TicketSaleThread(); TicketSaleThread t2 = new TicketSaleThread(); TicketSaleThread t3 = new TicketSaleThread(); t1.start(); t2.start(); t3.start(); } } class TicketSaleThread extends Thread{ private static int total = 100; public void run(){//直接锁这里,肯定不行,会导致,只有一个窗口卖票 while(total>0) { saleOneTicket(); } } public synchronized static void saleOneTicket(){//锁对象是TicketSaleThread类的Class对象,而一个类的Class对象在内存中肯定只有一个 if(total > 0) {//不加条件,相当于条件判断没有进入锁管控,线程安全问题就没有解决 System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total); } } }
示例二:非静态方法加锁
package com.haogu.safe; public class SaleTicketDemo4 { public static void main(String[] args) { TicketSaleRunnable tr = new TicketSaleRunnable(); Thread t1 = new Thread(tr, "窗口一"); Thread t2 = new Thread(tr, "窗口二"); Thread t3 = new Thread(tr, "窗口三"); t1.start(); t2.start(); t3.start(); } } class TicketSaleRunnable implements Runnable { private int total = 1000; public void run() {//直接锁这里,肯定不行,会导致,只有一个窗口卖票 while (total > 0) { saleOneTicket(); } } public synchronized void saleOneTicket(){//锁对象是this,这里就是TicketSaleRunnable对象,因为上面3个线程使用同一个TicketSaleRunnable对象,所以可以 if(total > 0) {//不加条件,相当于条件判断没有进入锁管控,线程安全问题就没有解决 System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total); } } }
示例三:同步代码块
package com.haogu.safe; public class SaleTicketDemo5 { public static void main(String[] args) { //2、创建资源对象 Ticket ticket = new Ticket(); //3、启动多个线程操作资源类的对象 Thread t1 = new Thread("窗口一") { public void run() {//不能给run()直接假设,因为t1,t2,t3的三个run方法分别属于三个Thread类对象, // run方法是非静态方法,那么锁对象默认选this,那么锁对象根本不是同一个 while (true) { synchronized (ticket) { ticket.sale(); } } } }; Thread t2 = new Thread("窗口二") { public void run() { while (true) { synchronized (ticket) { ticket.sale(); } } } }; Thread t3 = new Thread(new Runnable() { public void run() { synchronized (ticket) { ticket.sale(); } } }, "窗口三"); t1.start(); t2.start(); t3.start(); } } //1、编写资源类 class Ticket { private int total = 1000; public void sale() {//也可以直接给这个方法加锁,锁对象是this,这里就是Ticket对象 if (total > 0) { System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total); } else { throw new RuntimeException("没有票了"); } } public int getTotal() { return total; } }