Java多线程学习之三

最新推荐文章于 2023-08-17 16:12:39 发布

古藤老人

最新推荐文章于 2023-08-17 16:12:39 发布

阅读量98

点赞数

分类专栏：多线程文章标签：多线程 java 后端

本文链接：https://blog.csdn.net/weixin_43518498/article/details/111358612

版权

多线程专栏收录该内容

8 篇文章 0 订阅

订阅专栏

线程安全

1、关于多线程并发环境下，数据可能会存在安全问题。

2、什么数据在多线程并发的环境下会发生安全问题？

三个条件：

条件一：多线程并发
条件二：有共享数据
条件三：共享数据有修改行为

满足以上三个条件后，就会存在线程安全问题。

3、怎样解决线程安全问题？

线程同步机制

（1）线程排队执行（不能并发），用排队执行解决线程安全问题，
这种机制被称为线程同步机制

（2）线程同步就是线程排队，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，就没有效率的事儿。

4、说到线程同步这块，涉及到这两个专业术语：

（1）异步编程模型：

线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。
其实就是：多线程并发（效率较高。）异步就是并发。

（2）同步编程模型：

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

5、Java中有三大变量？【重要的内容。】

（1）实例变量：在堆中。

（2）静态变量：在方法区。

（3）局部变量：在栈中。

以上三大变量中：局部变量永远都不会存在线程安全问题。因为局部变量不共享（一个线程一个栈。），局部变量在栈中。所以局部变量永远都不会共享。
实例变量在堆中，堆只有1个。静态变量在方法区中，方法区只有1个。堆和方法区都是多线程共享的，所以可能存在线程安全问题。
局部变量和常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。

6、如果使用局部变量的话：建议使用StringBuilder。因为局部变量不存在线程安全问题。选择StringBuilder。StringBuffer效率比较低。

ArrayList是非线程安全的。
Vector是线程安全的。
HashMap HashSet是非线程安全的。
Hashtable是线程安全的。

7、多线程编程中的三个核心概念

（1）原子性：即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

（2）可见性：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

（3）有序性：程序执行的顺序按照代码的先后顺序执行。一般来说处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

8、内置锁（synchronized）

（1）每一个Java对象都可以用作一个实现同步的锁，称为内置锁，线程进入同步代码块之前自动获取到锁，代码块执行完成正常退出或代码块中抛出异常退出时会释放掉锁。内置锁为互斥锁，即线程A获取到锁后，线程B阻塞直到线程A释放锁，线程B才能获取到同一个锁。

（2）内置锁使用synchronized关键字实现，Synchronized是Java中解决并发问题的一种最常用最简单的方法，它可以确保线程互斥地访问同步代码块。

（3）synchronized有三种写法：

第一种：同步代码块（灵活）

synchronized(线程共享对象){
	同步代码块;
}

同步代码块，锁是Synchronized括号里匹配的对象

第二种：在实例方法上使用synchronized

表示共享对象一定是this，并且同步代码块是整个方法体。

普通同步方法，锁是当前实例对象

第三种：在静态方法上使用synchronized

表示找类锁。
类锁永远只有1把。
就算创建了100个对象，那类锁也只有一把。

静态同步方法，锁是当前类的Class对象

对象锁：1个对象1把锁，100个对象100把锁。
类锁：100个对象，也可能只是1把类锁。

（4）代码：

import java.util.ArrayList;
import java.util.List;

/**
 * @author 古藤老人
 * 用wait方法和notify方法实现生产者和消费者模式
 */
public class ThreadTest14 {
    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;
    }

    @Override
    public void run() {
        //一直生产
        while(true){
            //给仓库对象List加锁
            synchronized(list){
                if(list.size()>0){
                    //当前线程进入等待状态，并且释放Producer之前占有的List集合的锁
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序能够执行到这里说明仓库是空的，可以生产
                Object obj=new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName()+"--->"+obj);
                //唤醒消费者进行消费
                list.notify();
            }
        }
    }
}

//消费者线程
class Consumer implements Runnable{
    //仓库
    private List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //一直消费
        while(true){
            //给仓库对象List加锁
            synchronized(list){
                if(list.size()==0){
                    try {
                        //仓库已经空了
                        //消费者线程等待，释放List集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序能够执行到这里说明仓库是有数据，进行消费
                Object obj=list.remove(0);
                System.out.println(Thread.currentThread().getName()+"--->"+obj);
                //唤醒生产者生产
                list.notifyAll();
            }
        }
    }
}

9、什么是多线程死锁？

答:同步中嵌套同步,导致锁无法释放

package deadlock;
/*
死锁代码
 */
public class DeadLock {
    public static void main(String[] args) {
        Object o1=new Object();
        Object o2=new Object();
        //mt1,mt2共享c1,c2
        MyThread1 mt1=new MyThread1(o1,o2);
        MyThread2 mt2=new MyThread2(o1,o2);
        mt1.start();
        mt2.start();
    }
}

class MyThread1 extends Thread{
    Object o1;
    Object o2;
    public MyThread1(Object o1,Object o2){
        this.o1=o1;
        this.o2=o2;
    }
    @Override
    public void run() {
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){

            }
        }
    }
}

class MyThread2 extends Thread{
    Object o1;
    Object o2;
    public MyThread2(Object o1,Object o2){
        this.o1=o1;
        this.o2=o2;
    }
    @Override
    public void run() {
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){

            }
        }

    }
}

10、聊一聊，我们以后开发中应该怎么解决线程安全问题？

（1）是一上来就选择线程同步吗？synchronized

不是，synchronized会让程序的执行效率降低，用户体验不好。系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。

（2）解决方案

第一种方案：尽量使用局部变量代替“实例变量和静态变量”。
第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了。）
第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。

11、守护线程

（1）java语言中线程分为两大类：

一类是：用户线程
一类是：守护线程（后台线程）

其中具有代表性的就是：垃圾回收线程（守护线程）。

（2）守护线程的特点：

一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。

注意：主线程main方法是一个用户线程。

（3）守护线程用在什么地方呢？

每天00:00的时候系统数据自动备份。这个需要使用到定时器，并且我们可以将定时器设置为守护线程。一直在那里看着，没到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。

（4）代码：

public class ThreadTest12 {
    public static void main(String[] args) {
        Thread t=new BackUpThread();
        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 (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class BackUpThread extends Thread{
    @Override
    public void run() {
        int i=0;
        //即使是死循环，但由于是守护线程，当用户线程结束，守护线程自动终止
        while(true){
            System.out.println(Thread.currentThread().getName()+"--->"+(++i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

12、定时器

（1）定时器的作用：

间隔特定的时间，执行特定的程序。

（2）每周要进行银行账户的总账操作。每天要进行数据的备份操作。

在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
那么在java中其实可以采用多种方式实现：

可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）
在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

（4）代码：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {
    public static void main(String[] args) throws Exception {
        //创建定时器对象
        Timer timer=new Timer();
        //Timer timer1=new Timer(true);//守护线程的方式

        //指定定时任务
        //timer.schedule(定时任务,第一次执行时间,间隔多久执行一次);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime=sdf.parse("2020-11-29 21:07:00");
        //一年执行一次
        //timer.schedule(new LogTimerTask(),firstTime,1000*60*60*24*365);

        //匿名内部类的方式
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String strTime=sdf.format(new Date());
                System.out.println(strTime+"完成了一次数据备份！");
            }
        },firstTime,1000*5);

    }
}

/*
class LogTimerTask extends TimerTask {

    @Override
    public void run() {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strTime=sdf.format(new Date());
        System.out.println(strTime+"完成了一次数据备份！");
    }
}*/

13、应用

package threadSafe3;
/*
银行账户
    使用线程同步机制，解决线程安全问题
 */
public class Account {
    //账号
    private String actno;
    //余额
    private double balance;

    public Account() {
    }

    public Account(String actno, double balance) {
        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 synchronized void withdraw(double money){
        //以下几行代码必须是线程排队的，不能并发
        //一个线程把这里的代码全部执行完后，另一个线程才能进来
        double before=this.getBalance();
        double after=before-money;
            //模拟网络延迟
        try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        this.setBalance(after);
    }

}

package threadSafe3;

public class AccountThread extends Thread{
    //两个线程必须共用一个账户
    private Account act;
    //通过构造方法传来账户对象
    public AccountThread(Account act){
        this.act=act;
    }

    @Override
    public void run() {
        double money=5000;
        act.withdraw(money);
        System.out.println(Thread.currentThread().getName()+"对账户"+act.getActno()+"取款"+money+"成功，余额"+act.getBalance());
    }
}

package threadSafe3;

public class Test {
    public static void main(String[] args) {
        Account account=new Account("111111",10000);
        Thread t1=new AccountThread(account);
        Thread t2=new AccountThread(account);
        //设置线程名字
        t1.setName("t1");
        t2.setName("t2");
        //启动线程取款
        t1.start();
        t2.start();

    }
}

古藤老人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java多线程学习之三

线程安全1、关于多线程并发环境下，数据可能会存在安全问题。2、什么数据在多线程并发的环境下会发生安全问题？三个条件：条件一：多线程并发条件二：有共享数据条件三：共享数据有修改行为满足以上三个条件后，就会存在线程安全问题。3、怎样解决线程安全问题？线程同步机制（1）线程排队执行（不能并发），用排队执行解决线程安全问题，这种机制被称为线程同步机制（2）线程同步就是线程排队，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，就没有效率的
复制链接

扫一扫