您的位置 首页 java

Java并发编程之介绍线程安全基础

免费学习推荐:java基础教程

线程安全基础

  • 1.线程安全问题
  • 2.账户取款案例
  • 3.同步代码块synchronized
    • synchronized的理解
    • java中有三大变量的线程安全问题
    • 在实例方法上使用synchronized
    • 总结
    • 面试题
  • 4.死锁
  • 5.开发中应该怎么解决线程安全问题
  • 6.守护线程
  • 7.定时器
  • 8.实现线程的第三种方式:实现Callable接口
  • 9.Object类中的wait和notify方法
  • 10.生产者和消费者

1.线程安全问题

2.1、为什么这个是重点?
  以后在开发中,我们的项目都是运行在服务器当中,而服务器已经将线程的定义,线程对象的创建,线程的启动等,都已经实现完了。这些代码我们都不需要编写。
  最重要的是:你要知道,你编写的程序需要放到一个多线程的环境下运行,你更需要关注的是这些数据在多线程并发的环境下是否是安全的。(重点:*****)
2.2、什么时候数据在多线程并发的环境下会存在安全问题呢?
在这里插入图片描述
  三个条件:
  条件1:多线程并发。
  条件2:有共享数据。
  条件3:共享数据有修改的行为。

  满足以上3个条件之后,就会存在线程安全问题。
2.3、怎么解决线程安全问题呢?
当多线程并发的环境下,有共享数据,并且这个数据还会被修改,此时就存在线程安全问题,怎么解决这个问题?
  线程排队执行。(不能并发)。
  用排队执行解决线程安全问题。
  这种机制被称为:线程同步机制。

  专业术语叫做:线程同步,实际上就是线程不能并发了,线程必须排队执行
  怎么解决线程安全问题呀?
  使用“线程同步机制”。
  线程同步就是线程排队了,线程排队了就会牺牲一部分效率,没办法,数据安全第一位,只有数据安全了,我们才可以谈效率。数据不安全,没有效率的事儿。
2.4、说到线程同步这块,涉及到这两个专业术语:
异步编程模型:
  线程t1和线程t2,各自执行各自的,t1不管t2,t2不管t1,
  谁也不需要等谁,这种编程模型叫做:异步编程模型。
  其实就是:多线程并发(效率较高。)

同步编程模型:
  线程t1和线程t2,在线程t1执行的时候,必须等待t2线程执行结束,或者说在t2线程执行的时候,必须等待t1线程执行结束,两个线程之间发生了等待关系,这就是同步编程模型。效率较低。线程排队执行。

异步就是并发。同步就是排队。

2.账户取款案例

Account类

package ThreadSafe;public class Account {//账号private String actno;//余额private double balance;public Account(String actno, double balance) {super();this.actno = actno;this.balance = balance;}public String getActno() {return actno;}public void setActno(String actno) {this.actno = actno;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}//取款的方法public void withdraw(double money){//t1和t2并发执行这个方法(t1和t2是两个栈 ,两个栈操作堆中同一个对象)//取款之前的余额double before=this.getBalance();//取款之后的余额double after=before-money;//模拟一下网络延迟,会出现问题try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//更新余额//思考:t1执行到这里了,但还没有来得及执行这行代码,t2线程进来withdraw方法了,此时一定出问题this.setBalance(after);}}AccountThread类public class AccountThread extends Thread{//两个线程必须共享一个账户对象private Account act;//通过构造方法传递过来账户对象public AccountThread(Account act) {this.act = act;}@Overridepublic void run() {//假设取款5000double money=5000;//多线程执行这个方法act.withdraw(money);System.out.println(Thread.currentThread().getName()+"账户"+act.getActno()+"取款成功"+act.getBalance());}}

Test类

public class Test {public static void main(String[] args) {//创建账户对象Account act=new Account("act-001",10000);//创建两个线程Thread t1=new AccountThread(act);Thread t2=new AccountThread(act);t1.setName("t1");t2.setName("t2");//启动两个线程执行t1.start();t2.start();}}

在这里插入图片描述

3.同步代码块synchronized

synchronized的理解

//以下这几行代码必须是线程排队的,不能并发
//一个线程把这里的代码全部执行结束后,另一个线程才能进来
/*
线程同步机制的语法是
synchronized(){
//线程同步代码块。
}

synchronized后面小括号中传的这个数据是相当关键的,
这个数据必须是多线程共享的数据,才能达到多线程排队。
()中写什么?
那要看你想让哪些线程同步
假设t1、t2、t3、t4、t5有5个线程
你只希望t1 t2 t3排队,t4 t5不需要排队,怎么办
你一定要在()中写一个t1 t2 t3共享的对象,而这个对象对于t4 t5来说不是共享的
这里的共享对象是账户对象
账户对象是共享的,this是账户对象
有时不一定是this,这里只要是多线程共享的那个对象就行

synchronized(this){double before=this.getBalance();double after=before-money;try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}this.setBalance(after);}

在这里插入图片描述
在java语言中,任何对象都有一把锁,其实这把锁就是一个标记,(只是把它叫做锁)
100个对象,100个锁,1个对象1把锁。
以上代码的执行原理是什么呢?
1.假设t1和t2线程并发,开始执行以上代码的时候,肯定有一个先一个后,
2.假设t1先执行了,遇到了synchronized,这个时候自动找后面共享对象的对象锁,找到之后,并占有这把锁,然后执行同步代码块中的程序,在程序执行过程中一直都占有这把锁,直到同步代码块执行结束,这把锁才会释放。
3.假设t1已经占有这把锁,此时t2也遇到synchronized关键字,也会去占有后面共享对象的这把锁,结果这把锁被t1占有,t2只能在同步代码块外边等待t1的结束,直到t1把同步代码块执行结束了,t1会归还这把锁,此时t2终于等到这把锁,然后t2占有这把锁之后,进入同步代码块执行程序。
这样就达到了线程排队执行
这里需要注意的是:这个共享对象一定要选好了,这个共享对象一定是你需要排队执行的这些线程对象所共享的。
//对象
Object obj=new Object(); //实例变量(Account对象是多线程共享的,Account对象中的实例变量obj也是共享的)
synchronized(obj){}

在这里插入图片描述
括号里边只要是共享对象就行。
Object obj2=new Object(); //局部变量
synchronized(obj2){}
这样写就不安全了,因为obj2是局部变量,不是共享对象。
synchronized(“abc”){}
这样写时可以的。存在字符串常量池中
写"abc"的话所有线程都会同步

而如果是写synchronized(this){}的话,我们创建了一个新的对象act2可不用共享对象。
所以最好是写synchronized(this){},比如你要取款,要让其他取别的账户的人也要等吗?不应该,只有同时对你这1个账户取款的时候,需要等待,别人取钱的时候,需要从其他账户中取钱,就不需要等待。

java中有三大变量的线程安全问题

实例变量,在堆中
静态变量,在方法区
局部变量,在栈中

以上三大变量
局部变量永远不会存在线程安全问题
因为局部变量不共享(一个线程一个栈)
局部变量在栈中,所以局部变量永远都不会共享
实例变量在堆中,堆只有1个。
静态变量在方法区中,方法区只有1个

堆和方法区都是多线程共享的,所以可能存在线程安全问题

局部变量+常量:不会有线程安全问题。
成员变量:可能会有线程安全问题

同步代码块越小,效率越高。

//多线程执行这个方法//synchronized(this)//这里的this是AccountThread对象,这个对象不共享。synchronized(act){act.withdraw(money);System.out.println(Thread.currentThread().getName()+"账户"+act.getActno()+"取款成功,余额:"+act.getBalance());}

在实例方法上使用synchronized

在实例方法上可以使用synchronized吗?可以的。
synchronized出现在实例方法上,一定锁的是this
没得挑,只能是this,不能是其他的对象了
所以这种方式不灵活。
另外还有一个缺点:synchronized出现在实例方法上,表示整个方法体都需要同步
可能会扩大同步的范围,导致程序的执行效率降低。所以这种方式不常用
synchronized使用在实例方法上有什么优点?
代码写的少了,节俭了
如果共享的对象是this,并且需要同步的代码是整个方法体,建议使用这种方式
StringBuffer就是在每个方法上加了synchronized关键字

使用局部变量的话,最好使用StringBuilder
因为局部变量不存在线程安全问题,选择StringBuilder,StringBuffer效率比较低。
ArrayList是非线程安全的。
Vector是线程安全的。
HashMap HashSet是非线程安全的。
Hashtable是线程安全的

总结

synchronized有三种写法:

  第一种:同步代码块
    灵活
      synchronized(线程共享对象){
        同步代码块;
      }
  第二种:在实例方法上使用synchronized
      表示共享对象一定是this
      并且同步代码块是整个方法体。
  第三种:在静态方法上使用synchronized
      表示找类锁。
      类锁永远只有1把。
      就算创建了100个对象,那类锁也只有一把。

对象锁:1个对象1把锁,100个对象100把锁。
类锁:100个对象,也可能只是1把类锁。

面试题

//面试题:doother方法的执行需不需要等待dosome方法的结束。
//不需要,因为doother方法没有synchronized

public class exam01 {public static void main(String[] args) {MyClass mc=new MyClass();Thread t1=new MyThread(mc);Thread t2=new MyThread(mc);t1.setName("t1");t2.setName("t2");t1.start();try {Thread.sleep(1000);//这个睡眠的作用是:为了保证t1线程先执行} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}t2.start();}}class MyThread extends Thread{private MyClass mc;public MyThread(MyClass mc) {super();this.mc = mc;}public void run(){if(Thread.currentThread().getName().equals("t1")){mc.dosome();}if(Thread.currentThread().getName().equals("t2")){mc.doOther();}}}class MyClass{public synchronized void dosome(){System.out.println("doSome begin");try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("doSome end");}public void doOther(){System.out.println("doOther begin");System.out.println("doOther end");}}

在这里插入图片描述
当在doother上面加了synchronized呢
//面试题:doother方法的执行需不需要等待dosome方法的结束。
//需要,因为doother方法没有synchronized

public synchronized void doOther(){System.out.println("doOther begin");System.out.println("doOther end");}

//面试题:doother方法的执行需不需要等待dosome方法的结束。
//不用排队,谁也不用管谁

MyClass mc1=new MyClass();MyClass mc2=new MyClass();Thread t1=new MyThread(mc1);Thread t2=new MyThread(mc2);

//面试题:doother方法的执行需不需要等待dosome方法的结束。
//需要,因为静态方法是类锁,类锁不管创建了几个对象,类锁只有一把

MyClass mc1=new MyClass();MyClass mc2=new MyClass();Thread t1=new MyThread(mc1);Thread t2=new MyThread(mc2);public synchronized static void dosome(){System.out.println("doSome begin");try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("doSome end");}public synchronized static void doOther(){System.out.println("doOther begin");System.out.println("doOther end");}

这种锁叫排他锁:

4.死锁

在这里插入图片描述
synchronized在开发中最好不要嵌套使用,一不小心就可能导致死锁。
死锁代码要会写。
一般面试官要求你会写
只有会写的,才会在以后的开发中注意这个事儿
因为死锁很难调试。

public class DeadLock {public static void main(String[] args) {Object o1=new Object();Object o2=new Object();//t1线程和t2线程共享o1,o2Thread t1=new MyThread1(o1,o2);Thread t2=new MyThread2(o1,o2);t1.start();t2.start();}}class MyThread1 extends Thread{Object o1;Object o2;public MyThread1(Object o1,Object o2){this.o1=o1;this.o2=o2;}@Overridepublic void run() {synchronized (o1) {try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}synchronized (o2) {}}}}class MyThread2 extends Thread{Object o1;Object o2;public MyThread2(Object o1,Object o2){this.o1=o1;this.o2=o2;}@Overridepublic void run() {synchronized (o2) {try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}synchronized (o1) {}}}}

5.开发中应该怎么解决线程安全问题

聊一聊,我们以后开发中应该怎么解决线程安全问题?
  是一上来就选择线程同步吗?synchronized
  不是,synchronized会让程序的执行效率降低,用户体验不好。
  系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
  线程同步机制。
  第一种方案:尽量使用局部变量代替“实例变量和静态变量”。
  第二种方案:如果必须是实例变量,那么可以考虑创建多个对象,这样实例变量的内存就不共享了。(一个线程对应1个对象,100个线程对应100个对象,对象不共享,就没有数据安全问题了。)
  第三种方案:如果不能使用局部变量,对象也不能创建多个,这个时候就只能选择synchronized了。线程同步机制
线程这块还有那些内容呢?列举一下
7.1、守护线程
7.2、定时器
7.3、实现线程的第三种方式:FutureTask方式,实现Callable接口。(JDK8新特性。)
7.4、关于Object类中的wait和notify方法。(生产者和消费者模式!)

6.守护线程

守护线程
java语言中线程分为两大类:
  一类是:用户线程
  一类是:守护线程(后台线程)

其中具有代表性的就是:垃圾回收线程(守护线程)。
  守护线程的特点:
  一般守护线程是一个死循环,所有的用户线程只要结束,
  守护线程自动结束。
  注意:主线程main方法是一个用户线程。
  守护线程用在什么地方呢?
  每天00:00的时候系统数据自动备份。
  这个需要使用到定时器,并且我们可以将定时器设置为守护线程。
  一直在那里看着,没到00:00的时候就备份一次。所有的用户线程如果结束了,守护线程自动退出,没有必要进行数据备份了。

package testThread;/*实现守护线程 * */public class ThreadTest13 {public static void main(String[] args) {// TODO Auto-generated method stubThread t=new BakDataThread();t.setName("备份数据的线程");//启动之前,将线程设置为守护线程t.setDaemon(true);t.start();//主线程:主线程是用户线程for(int i=0;i<10;i++){System.out.println(Thread.currentThread().getName()+"---->"+i);try {Thread.sleep(1000);} catch (Exception e) {// TODO: handle exception}}}}class BakDataThread extends Thread{@Overridepublic void run() {int i=0;//即使是死循环,但由于该线程是守护者,当用户线程结束,守护线程自动终止while(true){System.out.println(Thread.currentThread().getName()+"---->"+(++i));try {Thread.sleep(1000);} catch (Exception e) {// TODO: handle exception}}}}

7.定时器

定时器的作用:
  间隔特定的时间,执行特定的程序。
  每周要进行银行账户的总账操作。
  每天要进行数据的备份操作。
  在实际的开发中,每隔多久执行一段特定的程序,这种需求是很常见的,
那么在java中其实可以采用多种方式实现:
  可以使用sleep方法,睡眠,设置睡眠时间,没到这个时间点醒来,执行任务。这种方式是最原始的定时器。(比较low)
  在java的类库中已经写好了一个定时器:java.util.Timer,可以直接拿来用。不过,这种方式在目前的开发中也很少用,因为现在有很多高级框架都是支持定时任务的。

  在实际的开发中,目前使用较多的是Spring框架中提供的SpringTask框架,这个框架只要进行简单的配置,就可以完成定时器的任务。

8.实现线程的第三种方式:实现Callable接口

实现线程的第三种方式:实现Callable接口。(JDK8新特性。)
这种方式实现的线程可以获取线程的返回值
之前讲解的那两种方式是无法获取线程返回值的,因为run方法返回void。
思考:
系统委派一个线程去执行一个任务,该线程执行完任务之后,可能会有一个执行结果,我们怎么能拿到这个执行结果呢
使用第三种方式:实现Callable接口方式

public class ThreadTest14 {public static void main(String[] args) throws Exception, ExecutionException {//第一步:创建一个未来任务类对象//参数非常重要,需要给一个callable接口的实现类对象FutureTask task=new FutureTask(new Callable(){@Override//call方法相当于是run方法,只不过这个有返回值,线程执行一个任务,执行之后可能会有一个执行结果。public Object call() throws Exception {System.out.println("call method begin");Thread.sleep(1000);System.out.println("call method begin");int a=100;int b=200;return a+b;//自动装箱}});//创建线程对象Thread t=new Thread(task);//启动线程t.start();//这里是main方法,这是在主线程中//在线程中,怎么获取t线程的执行结果//get方法的执行会导致当前线程阻塞Object obj=task.get();System.out.println("线程执行结果"+obj);//main方法这里的程序要想执行必须等待get()方法的结束//而get方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果。//另一个线程的执行是需要时间的System.out.println("hello,world");}}

这种方式的优点:可以获取到线程的执行结果
这种方式的缺点:效率比较低,在获取t线程执行结果的时候,当前线程受阻塞,效率较低。

9.Object类中的wait和notify方法

(生产者和消费者模式!)
  第一:wait和notify方法不是线程对象的方法,是java中任何一个java对象都有的方法,因为这两个方式是Object类中自带的。
  wait方法和notify方法不是通过线程对象调用,

  不是这样的:t.wait(),也不是这样的:t.notify()…不对。
  第二:wait()方法作用?
    Object o = new Object();
    o.wait();
  表示:
  让正在o对象上活动的线程进入等待状态,无期限等待,直到被唤醒为止。
  o.wait();方法的调用,会让“当前线程(正在o对象上活动的线程)”进入等待状态
  第三:notify()方法作用?
    Object o = new Object();
    o.notify();
  表示:
  唤醒正在o对象上等待的线程
  还有一个notifyAll()方法:
  这个方法是唤醒o对象上处于等待的所有线程。

在这里插入图片描述

10.生产者和消费者

在这里插入图片描述
1.使用wait方法和notify方法实现生产者和消费者模式
2.什么是生产者和消费者模式?
生产线程负责生产,消费线程负责消费
生产线程和消费线程要达到均衡
这是一种特殊的业务需求,在这种特殊的情况下需要使用wait方法和notify方法
3.wait和notify方法不是线程对象的方法,是普通java对象都有的方法
4.wait方法和notify方法是建立在线程同步的基础之上。因为多线程要同时操作一个仓库,有线程安全问题
5.wait方法作用:o.wait()让正在o对象上活动的线程t进入等待状态,并且释放掉t线程之前占有的o对象的锁
6.notify方法的作用:o.notify()让正在o对象上等待的线程唤醒,只是5通知,不会释放o对象上之前占有的锁
7.模拟这样一个需求:
仓库我们采用list集合
list集合中假设只能存储1个元素
1个元素就表示仓库满了
如果list集合中的元素个数是0,就表示仓库空了。
保证list集合中永远都是最多存储1个元素
必须做到这种效果,生产1个消费1个。

public class ThreadTest15 {public static void main(String[] args) {//创建一个仓库独享,共享的List list=new ArrayList();//创建两个线程对象//生产者线程Thread t1=new Thread(new Producer(list));//消费者线程Thread t2=new Thread(new Consumer(list));t1.setName("生产者线程");t2.setName("消费者线程");t1.start();t2.start();}}//生产线程class Producer implements Runnable{//仓库private List list;public Producer(List list) {this.list = list;}public void run() {//一直生产while(true){//给仓库对象list加锁synchronized (list) {if(list.size()>0){//大于0说明仓库中已经有1个元素了//当前线程进入等待状态,并且释放list集合的锁try {list.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}//程序能够执行到这里说明仓库是空的,可以生产Object obj =new Object();list.add(obj);System.out.println(Thread.currentThread().getName()+"---->"+obj);//唤醒消费者进行消费list.notifyAll();}}}}//消费线程class Consumer implements Runnable{//仓库private List list;public Consumer(List list) {this.list = list;}public void run() {//一直消费while(true){//给仓库对象list加锁synchronized (list) {if(list.size()==0){//仓里已经空了try {//仓库已经空了//消费者线程等待,并释放掉list集合锁list.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}Object obj=list.remove(0);System.out.println(Thread.currentThread().getName()+"---->"+obj);//唤醒生产者生产list.notifyAll();}}}

相关学习推荐:java基础

文章来源:智云一二三科技

文章标题:Java并发编程之介绍线程安全基础

文章地址:https://www.zhihuclub.com/14009.shtml

关于作者: 智云科技

热门文章

网站地图