线程（多线程间影响、线程同步、锁...）

已于 2023-02-03 15:18:03 修改
阅读量271 收藏
点赞数
文章标签： jvm Powered by 金山文档
于 2023-02-03 14:04:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_69032468/article/details/128822236
版权

    • 程序、进程、线程

● 程序：一段静态的代码，在电脑安装的静态代码文件。

● 进程：运行中的程序，是操作系统进行资源分配的最小单位。

● 线程：进程中最小的执行单位，cpu以线程为单位调度线程。

● 进程与线程的关系：

一个进程包含多个线程，一个线程只属于一个进程；

线程不能脱离进程独立运行；

一个进程中至少有一个线程，即主线程

2.创建线程

2.1继承Thread类

● 代码语法：

public class MyThread extends Thread{
    //需独立在线程中执行的任务，写在run();中

    @Override
    public void run() {
       
    }
}

public class Test {
    //顺序由操作系统决定
    public static void main(String[] args) {
    
        MyThread myThread=new MyThread();//创建线程对象
        myThread.start();//启动线程
    }
}

2.2实现Runnable接口

● 代码语法：

public class MyThread implements Runnable{

    @Override
    public void run() {
        
    }
}
public class Test {
    public static void main(String[] args) {
        
        //创建线程中需执行的任务，没有创建线程
        MyThread myThread=new MyThread();

        //创建线程，添加任务
        Thread thread=new Thread(myThread);
        thread.start();
        
    }
}

● 好处：

1. 可多继承其他类

2.适合多线程处理同一份资源

3.Thread类中方法

4.线程优先级

优先级以整数表示，范围是：1~10，一般线程的默认优先级为5，可通过setPriority()和getPriority()来设置，返回优先级。

优先级较高的线程有更多获得CPU的机会，反之亦然 。

Thread类有如下3个静态常量来表示优先级 ● MAX_PRIORITY：取值为10，表示最高优先级。 ● MIN_PRIORITY：取值为1，表示最底优先级。 ● NORM_PRIORITY：取值为5，表示默认的优先级。

5.线程状态

● 新建：当一个Thread类或其子类的对象被声明并创建时，此时不能执行；

● 就绪：处于新建状态的线程被start（）后，进入线程队列等待，此时可执行；

● 运行：当就绪的线程被调度且获得CPU执行权时，进入运行状态；

● 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，失去cpu执行权，临时中止自己的执行，进入阻塞状态

● 死亡：线程完成了它的全部工作/线程被提前强制性地中止/出现异常 导致结束。

6.守护线程

● Java中线程分为：用户线程和守护线程。

● 守护线程为其他线程的执行提供服务，只要当前JVM中存在非守护线程未结束，守护线程就全部运行。

● 二者的区别：若用户线程全部退出运行，守护线程会随之结束运行。

● 设置守护线程：

setDaemon(boolean on)

设置线程为守护线程要在启动线程前，否则会出现IllegalThreadStateException异常。

public class Test {
    public static void main(String[] args) {
        ThreadDemo t=new ThreadDemo();
        t.start();
        DaemonThread daemonThread=new DaemonThread();
        daemonThread.setDaemon(true);//必须写在线程启动前，设置线程为守护线程
        daemonThread.start();
    }
}


public class ThreadDemo extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("ThreadDemo"+i);
        }
    }
}

public class DaemonThread extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("DaemonThread");
        }
    }
}

7.多线程

7.1概念

指允许单个程序可以同时运行多个不同的线程来执行不同的任务。

7.2优缺点

● 优点：

提高CPU利用率；

提高程序响应；

改善程序结构，将复杂任务分为多个线程独立运行。

● 缺点：

内存随线程的增多而增大；

线程之间访问共享资源会受影响。

8.线程同步

8.1并发、并行

● 并发：一个时间段内一次执行操作。如：买票，看似同时进行，实则一个个进行。

● 并行：多个CPU同时执行多个任务。如：多个人同时做不同事。

8.2多线程同步

多线程同时共享同一份资源，会产生影响。故由线程”同步“来解决此问题。

8.3同步锁

可以是任何对象，但必须唯一，使得多个线程访问同一对象。

● 同步执行过程：

  1. 第一个线程访问，锁定同步对象，执行代码；

  1. 第二个线程访问，同步对象被锁定，无法访问；

  1. 第一个线程访问完毕，解锁同步对象；

  1. 第二个线程访问，锁定并访问。

Java中实现同步：

    • 使用synchronized关键字修饰

1.1修饰代码块

synchronized(键对象【可以为任何对象】){

必须多个线程对应同一个对象，

用该对象记录是否由线程进入到同步代码块中，

用该对象的对象头中的一块空间记录锁的状态。

}

//1.当继承Thread时
public class TicketThread extends Thread{
    static int num=10;//内存中只有一份，两线程对象共用同一份
    static String s=new String();//确保多个线程对应同一对象
    @Override
    public void run() {
        while(true){
            synchronized(s){
                if(num>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"买到了"+num--);
                }
                else{
                    break;
                }
            }
        }
    }
}


public class Test {
    public static void main(String[] args) {
        TicketThread t1=new TicketThread();
        t1.setName("1号");
        TicketThread t2=new TicketThread();
        t2.setName("2号");
        t1.start();
        t2.start();
    }
}


//2.当实现Runnable接口时
public class Ticket implements Runnable{
    int num=10;
    @Override
    public void run() {
        while(true){
            synchronized (this){//只创建了一个对象，仅有一个this
                if(num>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"买到了"+num--);
                }
                else{
                    break;
                }
            }
        }
    }
}


public class Test {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        Thread t1=new Thread(ticket,"1号");
        t1.start();
        Thread t2=new Thread(ticket,"2号");
        t2.start();
    }
}

1.2修饰方法
//1.当继承Thread时
public class TicketThread extends Thread{
    static int num=10;//内存中只有一份，两线程对象共用同一份
    static String s=new String();//确保多个线程对应同一对象
    @Override
    public void run() {
        while(true){
            if(num<=0){
                break;
            }
            TicketThread.printTicket();
        }
    }
    /*
    synchronized修饰非static方法时，键对象是this，可能有多个this，
    若修饰静态方法  staitc ,锁对象变为该类的class类的对象.
     */
    public  static synchronized void printTicket() {
        if(num>0){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买到了"+num--);
        }
    }
}


public class Test {
    public static void main(String[] args) {
        TicketThread t1=new TicketThread();
        t1.setName("1号");
        TicketThread t2=new TicketThread();
        t2.setName("2号");
        t1.start();
        t2.start();
    }
}

//2.当实现Runnable接口时
public class Ticket implements Runnable{
    int num=10;
    @Override
    public void run() {
        while(true){
            if(num<=0){
                break;
            }
            this.printTicket();
        }
    }
    public synchronized void printTicket(){
        if(num>0){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买到了"+num--);
        }

    }
}

public class Test {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        Thread t1=new Thread(ticket,"1号");
        t1.start();
        Thread t2=new Thread(ticket,"2号");
        t2.start();
    }
}

9.Lock锁

● 使用ReentrantLock类实现Lock,可以显示加锁，释放锁。

Lock lock=new ReentrantLock();
/*创建ReentrantLock对象，当有线程获取执行权时，底层state状态由0变为1
    若还有其他线程访问，都会进入到一个队列中等待
*/


lock.lock();//加锁

lock.unlock();//释放锁，一般写在finally代码块中，以防出现异常不能执行

10.线程死锁

● 多个线程分别占用对方所需的资源不放手，都在等待对方放弃自己所需的同步对象。程序不报错，也不提示。称为死锁。

● 代码举例：

public class DieLock extends Thread{
    //两把锁
    static Object objA=new Object();
    static Object objB=new Object();
    boolean flag;

    public DieLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if(flag){
            synchronized (objA){
                System.out.println("if objA");
            }
            synchronized (objB){
                System.out.println("if objB");
            }
        }
        else{
            synchronized (objB){
                System.out.println("else objB");
            }
            synchronized (objA){
                System.out.println("else objA");
            }
        }
    }
}



public class Test {
    public static void main(String[] args) {
        DieLock d1=new DieLock(true);
        DieLock d2=new DieLock(false);
        d1.start();
        d2.start();
    }
}

11.线程通信

11.1概念

● 多个线程通过相互牵制，相互调度，即线程间的相互作用。

11.2三方法

    wait();   在Object类 中定义，使线程进入等待状态，
             须通过notify() 进行唤醒，可自动释放锁对象。
    notify(;)  在Object类 中定义，唤醒等待中的线程
    notifyAll();  唤醒所有等待的线程
    以上方法，必须在同步代码块/同步方法中使用

11.3例题：生产者/消费者

假设生产者（Product）每次在柜台（Counter）上生产固定数量的商品（如：1个），且柜台不能再放商品，此时生产者停止生产，进入等待状态，来唤醒消费者消费，而消费者消费后，唤醒生产者，再进入等待状态。

public class Counter {
    int num=0;

    public synchronized void add(){
        if(num>0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        else{
            System.out.println("生产者生产");
            num+=1;
            this.notify();
        }
    }
    public synchronized void sub(){
        if(num==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        else{
            System.out.println("消费者消费");
            num-=1;
            this.notify();
        }

    }
}

public class Product extends Thread{

    Counter counter;
    public Product(Counter counter) {
        this.counter=counter;
    }

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter.add();
        }
    }
}

public class Customer extends Thread{

    Counter counter;
    public Customer(Counter counter) {
        this.counter=counter;
    }

    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter.sub();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Counter counter=new Counter();
        Product product=new Product(counter);
        Customer customer=new Customer(counter);
        product.start();
        customer.start();
    }
}

12.新增创建线程方式

● 实现Callable接口：

• 相比run（）方法，可以有返回值 • 方法可抛出异常 • 支持泛型的返回值 • 使用FutureTask类，获取返回结 果

//接收任务
FutureTask<Integer> futureTask = new FutureTask(任务);
//创建线程
Thread t = new Thread(futureTask);
t.start();
Integer val = futureTask.get();获得线程call方法的返回值

● 代码举例：

import java.util.concurrent.Callable;

public class Fun implements Callable {

    @Override
    public Integer call() throws Exception {
        int num=0;
        for (int i = 0; i < 100; i++) {
            num+=i;
        }
        return num;
    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Fun fun=new Fun();
        FutureTask<Integer> futureTask=new FutureTask<>(fun);
        Thread t=new Thread(futureTask);
        t.start();
        Integer s=futureTask.get();
        System.out.println(s);//4950
    }
}
小谭同学ha
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
6.C++中多线程.docx
11-23
本篇文章详细介绍了C++中多线程编程的基础知识，涵盖了多线程的创建、线程之间的通信、线程加锁和线程解锁、线程之间的同步等方面的知识点。通过学习这些知识点，可以更好地理解C++中多线程编程的原理和应用。
线程并发会带来什么问题
weixin_42611310的博客
01-04 123
当多个线程并发执行时，可能会产生以下问题： 竞争条件：多个线程竞争访问同一个资源，导致线程之间的数据矛盾。 死锁：多个线程互相等待对方释放某个资源，导致线程之间僵持不前。 削峰：如果线程处理时间过长，会导致其他线程等待时间过长，影响系统的效率。 安全性：如果线程访问共享数据时未加锁，可能导致数据破坏或访问冲突。 ...
进程与线程的区别？ 进程间通信与线程间通信
qq_40754866的博客
12-03 608
要理解进程与线程先来看多任务机制： 多任务处理机制是指用户可以在同一时间内运行多个应用程序，每个正在执行的应用程序被称为一个任务。多任务操作是系统使用某种调度（shedule）支持多个任务并发执行，多任务操作系统通常有三个基本概念：任务、进程和线程。 进程的基本概念：进程是指一个具有独立功能的程序在某个数据集合上的动态执行过程，它是操作系统进行资源分配的基本单元。简单的说，进程是一个程序的...
【思考】Java中多个线程操作同一个实例中的同一个方法会有什么影响？
Real___的博客
11-06 2300
本人是刚入门的小白，最近在重新学习spring；在理解spring中默认单例bean时引起了我对于标题的思考。 于是上网搜索，众多的回答给了我一点启发，但是都没有醍醐灌顶的感觉，当我尝试从硬件角度思考时似乎答案变得清晰了起来...
深究线程状态及切换
meiziziLOLOLO的博客
10-11 581
文章目录线程状态1.知识补充1.1 并行和并发1.2 锁池、等待池2.线程状态 线程状态 1.知识补充 1.1 并行和并发 并发：两个或多个事件在用一个时间段内发生 并行：两个或多个事件在同一时刻发生（同时发生） 在我们的计算机中，如果你的CPU是多核的，这个核的数量就是处理任务的线程的数量，比如你是双核的，那你的计算机便能并行处理两个任务。如果你只有单核，但又有多个任务或者双核有两个以上的任务，这时候怎么办呢？这时候就是并发处理任务了。 并发处理时，我们的CPU会在多个线程间反复横跳，一下子
c语言多线程参数相互影响,关于C语言多线程pthread库的相关函数说明
weixin_30126409的博客
05-18 389
线程相关操作说明一 pthread_tpthread_t在头文件/usr/include/bits/pthreadtypes.h中定义：typedef unsigned long int pthread_t;它是一个线程的标识符。二 pthread_create函数pthread_create用来创建一个线程，它的原型为：extern int pthread_create __P ((pthrea...
JAVA多线程共13页.pdf.zip
11-21
Java多线程是Java编程中的一个核心概念，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在现代计算机系统中，多线程技术被广泛应用，尤其是在服务器端应用、并发处理以及高并发场景下。这个"JAVA多...
利用读写锁保持线程同步.zip
02-20
在多线程编程中，线程同步是一个至关重要的概念，特别是在并发访问共享资源时，以避免数据不一致性和竞态条件。"利用读写锁保持线程同步"的主题旨在介绍如何使用读写锁来实现这一目标。读写锁是一种高级的线程同步...
多线程编程的入门指导.zip
06-19
在计算机科学中，多线程编程是一种允许程序同时执行多个任务或子任务的技术。它能够提升应用程序的效率和响应性，特别是在多核处理器系统中。本篇将详细讲解多线程编程的基础概念、应用场景以及如何在不同的编程语言...
完整版多线程模块.e.rar
04-02
线程安全是指一个函数或方法在多线程环境下能够正确工作，不会因线程间的相互干扰而产生错误。非线程安全的代码需要通过同步机制来改造。 **六、线程优先级** 操作系统为每个线程分配了一个优先级，决定线程被调度...
多线程中如何保证某段程序 连续执行，不被其他线程干扰
weixin_33795093的博客
08-24 2036
在程序中可能需要某段代码连续执行，不想被其他线程打断。对于不能被打断的操作我们叫它原子操作，为了能使线程中的某段代码成为原子操作，实现这个问题有要使用临界区加锁的办法，具体如下： Linux中使用临界区加锁的方法是用pthread_mutex_t进行操作，分别调用pthread_mutex_init、 pthread_mutex_destroy创建和释放pthread_mutex变量，调用pt...
java多线程--子线程的事务影响主线程吗
xinruyulu的博客
03-21 4254
1.子线程中抛出异常，会导致主线程中事务回滚吗？ 不会。子线程自身新开启了一个线程，不会影响主线程中的事务。 因此：TP中报文发送和报文接收线程中：新创建的具体报文处理线程，各自间的事务互不影响。 这种设计：属于生产者--消费者模式 2.结束线程的方式： 1.抛出异常 2.使用interrupt方法，stop方法已废弃。 3.事务回滚： 在service层中抛出异常，才会进
spring的线程、数据库连接和事务之间的关系
软件界的鼬神
11-19 3678
问题的由来： 通常我们在直接操作数据库的时候，先连上数据库，然后执行sql，那么执行一次sql就有一次事务提交，同一个连接下可以有无数的事务，而在开发的时候通常我们都是在service里面进行数据库操作比如： @Transactional @Override public void myTest(Test updateVO) { Test test = testDao.selectById(updateVO.getId()); t...
BUG记录-多线程对事务的影响有多么大？
小码农薛尧的博客
10-14 377
问题描述 有一天，测试妹子W向我提了一个BUG，问题描述如下，当操作动作D时，动作D可以看作更新，更新我当前选择的那一条数据，妹子W看到操作D成功页面中多出一条一样的数据，期望的结果是只会更新当前选择行的数据，并不会新增多余的数据。 问题原因 开始的时候，我认为代码有问题，查看一下代码，应该没有太大的问题，普通操作动作D时，数据会更新，不会新增多余的数据，但是在出现异常时，这个问题，就会复现出来，我当前猜想应该有事务有关系。 现在我先说明一下，动作D的业务逻辑，当我们点击动作D时，首先会调用更新操作，更新数
线程相关知识[1]
YEEYang12的博客
03-28 682
线程和进程 进程是计算机正在执行的一个独立的应用程序，是一个动态的概念，即必须是进行状态，如果一个应用程序没有启动，就不是进程 线程是组成进程的基本单位，可以完成特定的功能，一个进程由一个或多个线程组成 进程和线程的区别与联系 1、内存空间：进程是有独立的内存空间，进程之间相互独立，互不干扰；线程共享内存空间。 2、安全性：进程之间相互独立，一个进程的崩溃不会影响到其他的进程；线程内存共享，一个线程的崩溃可能会影响到其他线程的执行，线程的安全性不如进程 联系：一个进程可以包含一个或多个线程 java
ThreadLocal遇到线程池时, 各线程间的数据会互相干扰
希望我的博客，能解决你工作中的问题
11-13 1615
1、问题现象 在一个服务中，我们为了不修改接口，且能在当前线程传递数据，想到了用ThreadLocal保存数据， 测试环境一切正常， 上生产环境后发现，当前线程去ThreadLocal保存的用户数据的时候，莫名其妙的取到了，其它用户的数据。 2、问题原因 首先我排查了ThreadLocal 中存、取数据的过程，没有线程安全的问题， 然后怀疑是项目中用了线程池复用线程导致数据混乱，排查后发现项目中并...
Java多线程-线程的安全问题与线程的同步机制介绍
最新发布
01-29
"Java多线程编程中，线程安全问题和同步机制是核心话题。本文将探讨线程安全问题的产生原因以及如何通过不同方式解决，包括实现Runnable接口和继承Thread类。此外，还将分类总结线程安全问题，如局部变量、实例变量...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小谭同学ha

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值