Java多线程基础与线程安全

最新推荐文章于 2023-11-24 18:24:19 发布
最新推荐文章于 2023-11-24 18:24:19 发布
阅读量160 收藏 1
点赞数 1
分类专栏： JavaSE 文章标签： java 多线程 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42193813/article/details/107848067
版权

多线程基础

线程基础知识

java有2个线程：main，GC

java不能开启线程，因为Java无法直接操控硬件，所以实际上是调用了本地方法(C++)去开启线程

什么是进程？

进程是程序在并发环境中的执行过程

什么是线程？

线程是CPU调度的最小单位

进程和线程的区别

  • 进程是操作系统资源分配的基本单位，线程是CPU的基本调度单位

  • 一个程序运行后至少有一个进程

  • 一个进程可以包含多个线程，但是至少需要有一个线程

  • 进程之间不能共享数据段地址，但同进程的线程之间可以


线程的组成

  • CPU时间片：OS会为每个线程分配执行时间
  • 运行数据：
  • ​ 堆空间：存储线程需要使用的对象，多个线程可以共享堆中的对象
  • ​ 栈空间：存储线程需要使用的局部变量，每个线程都拥有独立的栈
  • 线程的逻辑代码

线程的执行特点

  • 抢占式执行：效率高、可防止单一线程长时间独占CPU
  • 在单核CPU中，宏观上同时执行，微观上顺序执行

线程6种状态

6种状态：新建、执行、阻塞、等待、超时等待、终止

public enum State {
    
    // 尚未启动的线程
    NEW,

    // 可执行
    RUNNABLE,

    // 阻塞
    BLOCKED,

    // 等待
    WAITING,

    // 超时等待
    TIMED_WAITING,

    // 终止
    TERMINATED;
}

线程6种状态

  • 注：JDK5之后就绪、运行统称RUNNABLE

创建、使用线程

1、继承Thread类

public class MyThread extends Thread{

    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start();
        thread2.start();
    }

    @Override
    public void run() {
        for(int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }
}

获取线程名字

System.out.println(Thread.currentThread().getName());

获取线程ID

System.out.println(Thread.currentThread().getId());

修改线程名称：第一种方法

MyThread thread1 = new MyThread();
thread1.setName("A");

修改线程名称：第二种方法

public MyThread(String name) {
    super(name);
}

MyThread thread1 = new MyThread("A");

小练习-售票1

两个站点买票，各卖100张票，一共卖200张

public class Station extends Thread{
    private int ticket = 30;

    public Station() {
    }

    public Station(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (true) {
            if (ticket <= 0) {
                System.out.println(Thread.currentThread().getName() + " 票卖完了");
                break;
            }
            System.out.println(Thread.currentThread().getName() + " 卖出了第 " + (30 - ticket) + " 张票");
            ticket--;
        }
    }
}

public class StationTest {
    public static void main(String[] args) {
        Station station1 = new Station("窗口1");
        Station station2 = new Station("窗口2");
        station1.start();
        station2.start();
    }
}

内存图

每个线程都会拥有一个自己的栈
在这里插入图片描述

2、实现Runnable接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable, "A");
        Thread thread2 = new Thread(myRunnable, "B");
        thread1.start();
        thread2.start();
    }
}

小练习-售票2

两个窗口，销售同一个站点的票，共卖30张

（目前没有保证安全性问题，主要用来理解内存图）

public class Station implements Runnable {
    private int ticket = 30;

    @Override
    public void run() {
        while (true) {
            if (ticket <= 0) {
                System.out.println(Thread.currentThread().getName() + " 票卖完了");
                break;
            }
            System.out.println(Thread.currentThread().getName() + " 卖出了第 " + (30 - ticket) + " 张票");
            ticket--;
        }
    }
}

public class StationTest {
    public static void main(String[] args) {
        Station station = new Station();
        Thread thread1 = new Thread(station, "窗口1");
        Thread thread2 = new Thread(station, "窗口2");
        thread1.start();
        thread2.start();
    }
}

查看源码

存储线程的名字

private volatile String name;

存储可执行的对象（此例子中存储的就是station对象）

private Runnable target;

构造方法：将两个参数传入，最后进行赋值

public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}

内存图

每个线程都拥有一个自己的栈
在这里插入图片描述

3、Callable

带返回值的方式

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            private int count = 100;
            @Override
            public Integer call() throws Exception {
                count += 100;
                return count;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        Integer result = futureTask.get();
        System.out.println("结果: " + result);
    }
}

线程的常用方法

sleep()与wait()方法

另一种休眠方式

TimeUnit.SECONDS.sleep(1000);

sleep

进入休眠状态，休眠之后，不会抢占CPU，休眠结束后，进入就绪状态


wait

线程进入等待队列等待，释放CPU和锁，等待结束后，进入就绪状态


sleep与wait的区别

  • sleep是线程进入休眠状态，wait是线程进入等待队列
  • sleep会释放CPU，不会释放锁；wait会释放CPU和锁
  • sleep必须捕获异常，wait不用捕获异常

yield()方法

主动放弃CPU时间片，回到就绪状态，竞争下一次时间片

只把CPU使用权让给和自己权限相同，或者比自己权限更高的线程


join()方法

允许其它线程加入到当前线程中，并阻塞当前线程，等待加入线程执行完毕

（也就是阻塞，并等待加入线程执行完毕）

/**
 * @author 张宝旭
 */
public class SleepTest {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + " 滴滴..." + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        try {
            System.out.println("thread.join start......");
            thread.join();
            System.out.println("thread.join end......");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main end......");
    }
}

执行结果

thread.join start......
Thread-0 滴滴...0
Thread-0 滴滴...1
Thread-0 滴滴...2
Thread-0 滴滴...3
Thread-0 滴滴...4
thread.join end......
main end......

interrupt()方法

中断线程

thread.interrupt();

setDaemon()方法

设置为守护线程

thread.setDaemon(true);

线程安全

什么是线程安全

  • 当多线程并发访问临界资源时，如果破坏原子操作，可能会造成数据不一致。
    • 临界资源：共享资源，一次仅允许一个线程使用，才可保证其正确性
    • 原子操作：不可分割的多步操作，被视为一个整体，其顺序和步骤不可打乱缺省

synchronized

JDK1.6之后synchronized的优化：

  1. JDK1.6之前只有两种状态：无锁和重量级锁，JDK1.6之 后有四种状态：无锁、偏向锁、轻量级锁、重量级锁，无锁–>偏向锁–>轻量级锁–>重量级锁，只能升级不能降级。
  2. 优化策略：锁消除、锁粗化、自旋锁(jdk1.4包含) 、自适应自旋锁
    自旋锁是在轻量级锁升级为重量级时使用的优化策略。

同步代码块

synchronized (临界资源对象) {
    // 代码
}
  • 只有拥有对象互斥锁标记的线程，才能进入对该对象加锁的同步代码块。
  • 线程退出同步代码块时，会释放相应的互斥锁标记。

售票例子

public class Station implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (ticket <= 0) {
                    System.out.println(Thread.currentThread().getName() + " 票卖完了");
                    break;
                }
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + (100 - ticket) + " 张票");
                ticket--;
            }
        }
    }
}

public class StationTest {
    public static void main(String[] args) {
        Station station = new Station();
        Thread thread1 = new Thread(station, "窗口1");
        Thread thread2 = new Thread(station, "窗口2");
        Thread thread3 = new Thread(station, "窗口3");
        Thread thread4 = new Thread(station, "窗口4");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

执行结果：不同线程，按顺序卖出

窗口1 卖出了第 0 张票
窗口2 卖出了第 1 张票
窗口2 卖出了第 2 张票
窗口2 卖出了第 3 张票
...

同步方法

  • 非静态方法，锁住的是当前对象

  • 静态方法，锁住的是当前类

public synchronized void show() {
    for(int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName() + "...");
    }
}
她的坏机器人
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程-线程安全问题练习题
01-30
Java多线程--线程安全问题练习题
【Java系列】详解多线程（三）—— 线程安全（上篇）
最新发布
m0_74352571的博客
12-16 1042
【Java系列】详解多线程（三）—— 线程安全（上篇）
Java多线程与线程安全
weixin_44713530的博客
11-24 50
多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。
java多线程与线程安全问题
elicious的博客
06-04 377
/1.重写run方法：现成的执行任务@Overridei < 20;i++) {//1.创建线程对象//2.开启线程 ---当获取到cpu时间片，那么该线程就会执行run方法的任何代码//多线程//一个线程，先执行run，在执行mainj < 30;j++) {获取当前线程的名称第一种: 通过父类Thread中的getName()可以获取线程名称。必须为Thread的子类。
Java多线程之线程安全问题
未见花闻的博客
04-02 8576
本篇文章介绍的内容为Java多线程中的线程安全问题，此处的安全问题并不是指的像黑客入侵造成的安全问题，线程安全问题是指因多线程抢占式执行而导致程序出现bug的问题。
Java线程安全
qq_40132294的博客
10-10 2万+
前段时间有测试一个后端对账单和话单采集服务,在测试过程中有涉及到数据库读写逻辑和并发的场景,所以结合经验针对系统技术架构设计了部分并发场景结合数据库读写时可能出现的一些问题的用例,也确实出现了一些测试环境容易忽视,线上环境确确实实可能出现的问题,当然最后还是得到了妥善的解决.下面说说后端测试应该考虑的一些线程安全和数据读写方面的问题. 前提:测试环境的架构尽量向线上环境的架构靠拢,比如线上如果采用分布式集群,测试环境如果是单机,那么部分问题自然无法暴露,如果测试环境无足够资源模拟线上的几十台集群环境,那么
Java多线程与线程安全实践-基于Http协议的断点续传
08-04
Java多线程与线程安全实践-基于Http协议的断点续传 Java多线程与线程安全实践-基于Http协议的断点续传 Java多线程与线程安全实践-基于Http协议的断点续传 Java多线程与线程安全实践-基于Http协议的断点续传 Java多...
java多线程安全性基础介绍.pptx
07-25
java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 i++ 读i ++ 值写回i 可见性 JMM 由于cpu和内存加载速度的差距，在两者之间增加了多级缓存导致，内存并不能直接对cpu可见。 ...
Java多线程安全问题和锁
01-20
多线程安全问题和锁 文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样...
Java多线程之CAS算法实现线程安全
08-25
主要介绍了java中如何通过CAS算法实现线程安全，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面小编和大家一起来学习一下吧
java中的线程安全
qq_66013742的博客
08-26 1477
加了锁之后，有一个线程进到锁里面没有出来，导致锁资源没有得到释放，其他线程一直等待锁资源的释放，这样就导致了死锁的产生同步代码块和同步方法都是自动释放锁资源，所以不容易出现死锁；如果需要演示死锁案例；在同步锁中需要进行锁嵌套；注意：此处只是为了测试死锁，才进行的锁嵌套；以后使用时尽量避免锁嵌套(避免死锁)线程池：就是装线程的容器，预先在容器中创建指定个数的线程对象；当用户需要时，直接俄从容器中获取；用完了，再回收到线程池中（用完了放回去之前创建线程的方式：创建线程对象后，执行完毕则销毁线程对象；
Java 线程安全
weixin_63025863的博客
07-18 1101
Java 线程安全问题剖析及如何控制多线程环境下，并发编程的执行顺序。
Java之线程安全
qq_64580912的博客
05-10 4213
线程1获取到锁之后执行了对应的代码,线程2也要执行这个方法,但是检查锁的状态已经被持有,所以它处在堵塞(BLOCK)的状态,当线程1执行完方法之后,线程2才有可能获得到锁(并不一定),因为线程是抢占式执行的,可能线程1再次执行这个方法,再次先获得到了锁.现在举一个形象点的例子,小人1去上厕所,它获取到了锁,进入到上厕所,其他的小人要想上厕所,因为现在已经上了锁,所以他们只能处在等待堵塞的状态,当小人1出来之后,他们又在一起竞争(小人1也参与竞争),竞争到锁的就可以先上厕所,其它的小人又需要等待,
java---线程安全详解
m0_58196614的博客
08-10 4270
线程安全是指某个方法或某段代码，在多线程中能够正确的执行，不会出现数据不一致或数据污染的情况，我们把这样的程序称之为线程安全的，反之则为非线程安全的。
【超详细】深入探究Java中的线程安全，让你的程序更加可靠~
热门推荐
仨仨的博客
03-26 2万+
线程安全指的是多个线程并发访问共享资源时，不会出现数据不一致或其他意外情况的情况。在多线程编程中，线程安全非常重要，因为多个线程可能会同时访问和修改同一数据，如果不进行适当的同步处理，就可能导致数据不一致、竞态条件和死锁等问题。为了实现线程安全，需要使用一些技术和方法来保证数据的一致性和同步性，例如锁机制、原子操作、线程局部变量等。常用的线程安全类包括Vector、CopyOnWriteArrayList、Hashtable、ConcurrentHashMap、原子类等。
什么是线程安全？Java中如何保障线程安全？
杨荧的CSDN博客
06-14 1719
什么是线程安全？Java中如何保障线程安全？
java中的线程安全是什么？什么叫线程安全？什么叫不安全？
a304096740的博客
03-20 519
java中的线程安全是什么： 就是线程同步的意思，就是当一个程序对一个线程安全的方法或者语句进行访问的时候，其他的不能再对他进行操作了，必须等到这次访问结束以后才能对这个线程安全的方法进行访问 什么叫线程安全： 如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和...
java多线程基础知识
07-28
Java多线程基础知识主要包括以下几个方面： 1. 线程的创建和启动：可以通过继承Thread类或实现Runnable接口来创建线程，并使用start()方法来启动线程。 2. 线程的生命周期：线程的生命周期包括新建、就绪、运行、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值