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

这篇文章主要介绍了Java并发编程之介绍线程安全基础的示例，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。

线程安全基础

• 线程安全问题

• 账户取款案例

• 同步代码块synchronized

• synchronized的理解

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

• 在实例方法上使用synchronized

• 总结

• 面试题

• 死锁

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

• 守护线程

• 定时器

• 实现线程的第三种方式：实现Callable接口

• Object类中的wait和notify方法

• 生产者和消费者

1.线程安全问题

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的理解

//以下这几行代码必须是线程排队的，不能并发
//一个线程把这里的代码全部执行结束后，另一个线程才能进来
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并发编程之介绍线程安全基础的示例”这篇文章对大家有帮助，同时也希望大家多多支持编程网，关注编程网精选频道，更多相关知识等着你来学习!