【Java学习笔记】多线程

最新推荐文章于 2024-08-01 15:33:26 发布
最新推荐文章于 2024-08-01 15:33:26 发布
阅读量53 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45699792/article/details/116481500
版权

教程

文章目录

4 线程的生命周期

在这里插入图片描述
在这里插入图片描述

5 多线程存在的问题

5.1线程安全

多线程共享数据时，如果没有采取正确的并发访问控制措施，就可能会产生数据一致性问题

5.1.1原子性

在这里插入图片描述

package threadsafe;

import java.util.concurrent.atomic.AtomicInteger;

public class Test01 {
    public static void main(String args[]){
        MyInt myInt = new MyInt();

        for (int i = 1; i < 2; i++){
            {new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        System.out.println(Thread.currentThread().getName()+myInt.getNum());
                        try {
                            Thread.sleep(100);
                        }
                        catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }
                }
            }).start();

            }
        }
    }

    static class MyInt{
        AtomicInteger num = new AtomicInteger();
        public int getNum(){
            return num.getAndIncrement();
        }
    }
}

5.1.2 可见性

在这里插入图片描述

5.1.2.1使用synchronized关键词
package threadsafe;

import charactor.Hero2;

public class Test02 {

    public static void main(String[] args) {

        final Object someObject = new Object();

        final Hero2 gareen = new Hero2();
        gareen.name = "盖伦";
        gareen.hp = 10000;

        int n = 10000;

        Thread[] addThreads = new Thread[n];
        Thread[] reduceThreads = new Thread[n];

        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){

                    //任何线程要修改hp的值，必须先占用someObject
                    synchronized (someObject) {
                        gareen.recover();
                    }

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            addThreads[i] = t;

        }

        for (int i = 0; i < n; i++) {
            Thread t = new Thread(){
                public void run(){
                    //任何线程要修改hp的值，必须先占用someObject
                    synchronized (someObject) {
                        gareen.hurt();
                    }

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            t.start();
            reduceThreads[i] = t;
        }

        for (Thread t : addThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        for (Thread t : reduceThreads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        System.out.printf("%d个增加线程和%d个减少线程结束后%n盖伦的血量是 %.0f%n", n,n,gareen.hp);

    }

}
5.1.2.2 使用Lock

与 synchronized (someObject) 类似的，lock()方法，表示当前线程占用lock对象，一旦占用，其他线程就不能占用了。
与 synchronized 不同的是，一旦synchronized 块结束，就会自动释放对someObject的占用。 lock却必须调用unlock方法进行手动释放，为了保证释放的执行，往往会把unlock() 放在finally中进行。

package threadsafe;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test02 {

    public static String now() {
        return new SimpleDateFormat("HH:mm:ss").format(new Date());
    }

    public static void log(String msg) {
        System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
    }

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();

        Thread t1 = new Thread() {
            public void run() {
                try {
                    log("线程启动");
                    log("试图占有对象：lock");

                    lock.lock();

                    log("占有对象：lock");
                    log("进行5秒的业务操作");
                    Thread.sleep(5000);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    log("释放对象：lock");
                    lock.unlock();
                }
                log("线程结束");
            }
        };
        t1.setName("t1");
        t1.start();
        try {
            //先让t1飞2秒
            Thread.sleep(2000);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        Thread t2 = new Thread() {

            public void run() {
                try {
                    log("线程启动");
                    log("试图占有对象：lock");

                    lock.lock();

                    log("占有对象：lock");
                    log("进行5秒的业务操作");
                    Thread.sleep(5000);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    log("释放对象：lock");
                    lock.unlock();
                }
                log("线程结束");
            }
        };
        t2.setName("t2");
        t2.start();
    }

}
5.1.2.3使用volatile关键词

5.1.3 有序性

5.2 线程活性

由于程序自身缺陷或者资源稀缺性导致线程一直处于非runnnable状态。死锁（Deadlock）；锁死（Lockout）；活锁（Livelock）；饥饿（Starvation）

5.3 线程交互

使用wait和notify进行线程交互

package charactor;
 
public class Hero {
    public String name;
    public float hp;
 
    public int damage;
 
    public synchronized void recover() {
        hp = hp + 1;
        System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
        // 通知那些等待在this对象上的线程，可以醒过来了，如第20行，等待着的减血线程，苏醒过来
        this.notify();
    }
 
    public synchronized void hurt() {
        if (hp == 1) {
            try {
                // 让占有this的减血线程，暂时释放对this的占有，并等待
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
 
        hp = hp - 1;
        System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);
    }
 
    public void attackHero(Hero h) {
        h.hp -= damage;
        System.out.format("%s 正在攻击 %s, %s的血变成了 %.0f%n", name, h.name, h.name, h.hp);
        if (h.isDead())
            System.out.println(h.name + "死了！");
    }
 
    public boolean isDead() {
        return 0 >= hp ? true : false;
    }
 
}

package multiplethread;
      
import java.awt.GradientPaint;
    
import charactor.Hero;
      
public class TestThread {
      
    public static void main(String[] args) {
    
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
             
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                       
                    //无需循环判断
//                    while(gareen.hp==1){
//                        continue;
//                    }
                       
                    gareen.hurt();
                     
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
   
            }
        };
        t1.start();
   
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    gareen.recover();
   
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
   
            }
        };
        t2.start();
             
    }
          
}

6 线程池

package multiplethread;
      
import java.awt.GradientPaint;
    
import charactor.Hero;
      
public class TestThread {
      
    public static void main(String[] args) {
    
        final Hero gareen = new Hero();
        gareen.name = "盖伦";
        gareen.hp = 616;
             
        Thread t1 = new Thread(){
            public void run(){
                while(true){
                       
                    //无需循环判断
//                    while(gareen.hp==1){
//                        continue;
//                    }
                       
                    gareen.hurt();
                     
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
   
            }
        };
        t1.start();
   
        Thread t2 = new Thread(){
            public void run(){
                while(true){
                    gareen.recover();
   
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
   
            }
        };
        t2.start();
             
    }
          
}

package multiplethread;
 
public class TestThread {
       
    public static void main(String[] args) {
        ThreadPool pool = new ThreadPool();
  
        for (int i = 0; i < 5; i++) {
            Runnable task = new Runnable() {
                @Override
                public void run() {
                    //System.out.println("执行任务");
                    //任务可能是打印一句话
                    //可能是访问文件
                    //可能是做排序
                }
            };
             
            pool.add(task);
             
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
  
    }
           
}

package multiplethread;
  
public class TestThread {
    public static void main(String[] args) {
        ThreadPool pool= new ThreadPool();
        int sleep=1000;
        while(true){
            pool.add(new Runnable(){
                @Override
                public void run() {
                    //System.out.println("执行任务");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
            try {
                Thread.sleep(sleep);
                sleep = sleep>100?sleep-100:sleep;
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
              
        }
          
    }
}
weixin_45699792
关注
java学习笔记 多线程练习题总结
qq_43596503的博客
10-22 1810
一、判断题 1. C和Java都是多线程的。 （ ） 答案：错误 知识点：C 是单线程语言。 2.如果线程死亡，它便不能运行。 （ ） 答案：正确 知识点：线程死亡就意味着它不能运行。 3.在 Java 中，高优先级的可运行线程会抢占低优先级线程。（ ） 答案：正确 知识点：线程优先级的使用。 4.程序开发者必须创建一个线程去管理内存的分配。（ ） 答案：错误 知识点：Java 提供了一个系统线程来管理内存的分配。...
Java 学习多线程笔记
cyberscutoid的博客
03-07 2242
多线程的目的 为了更合理的利用cpu资源 多线程的概念 一个进程运行时产生多个线程 并行与并发 并行：多个cpu实例同时执行一段逻辑 并发：通过cpu调度算法，让程序看上去像是同时执行，提高程序运行效率。 线程安全 线程安全：在并发的前提下，该代码经过多线程的使用，线程的调度顺序不影响产生的结果。 线程不安全：与线程安全相反，线程的调度顺序影响最终的结果 同步：通过人为的控制与调度，保证共享资源的多线程访问成为线程安全，确保结果的准确。 调度：1.分时 2.抢占
Java多线程学习笔记
qq_44903634的博客
08-01 1431
wait()会使“当前线程”等待，因为线程进入等待状态，所以线程应该释放它锁持有的“同步锁”，否则其它线程获取不到该“同步锁”而无法运行！其他线程获取“该对象的同步锁”(
Java 多线程学习笔记
2301_76962889的博客
07-13 1888
*进程：**是操作系统进行资源分配和调度的基本单位，是程序的一次执行过程。**例如：**当你打开一个应用程序，如浏览器、音乐播放器等，操作系统就会为其创建一个进程。**线程：**是进程的一个执行单元，是 CPU 调度和分派的基本单位，一个进程可以包含多个线程。**例如：**在浏览器进程中，可以有多个线程同时运行，例如一个线程负责页面渲染，另一个线程负责网络请求。提高 CPU 利用率，充分利用多核处理器**例如：**下载软件使用多线程可以同时下载多个文件片段，充分利用带宽，提高下载速度。
狂神说Java学习笔记——多线程
weixin_65098078的博客
07-19 1521
狂神说Java学习笔记——多线程
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3456
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java学习笔记-多线程
cyh0503的博客
07-08 2839
并发与并行 并发：指两个或多个事件在同一个时间段内发生 并行：指两个或多个事件在同一时刻发生（同时发生） 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java学习笔记
Piglett的博客
12-30 1131
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java多线程笔记详解
you are sherlocked by me!
10-09 559
这是学习多线程知识的学习笔记，大家可以选择自己感兴趣的部分阅读学习 详细代码见github代码   Java多线程学习笔记1之多线程基础 内容: 1) 基本概念以及线程的实现方法   Java多线程学习笔记2之多线程基础 内容: 1) 数据同步 2) 非线程安全情况以及处理方法 3) Java内存模型 4) Thread.currentThread()抽象方法使用 ...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
多线程-狂神说Java学习笔记
07-19
本学习笔记将深入探讨Java多线程的相关知识，包括其原理、实现方式、同步机制以及常见问题。 ### 一、多线程的基本概念 多线程是指在一个程序中存在两个或更多的执行线程，这些线程共享同一内存空间，但各自拥有...
(完整版)最全的java学习笔记(必看).pdf
05-27
Java学习笔记 Java是一种流行的编程语言，广泛应用于Android应用程序开发、Web应用程序开发、桌面应用程序开发等领域。以下是Java学习笔记的摘要信息： 一、Java技术基础 * 1.1 编程语言：Java是一种面向对象的...
基于Python实现的WHRP治理设计与源码分享
09-30
本项目是一款基于Python的WHRP治理设计与源码，包含20个文件，其中包括16个Python源代码文件、2个Markdown文件、1个Git忽略文件和1个许可证文件。该设计旨在通过Python实现WHRP治理，为用户提供高效、可靠的解决方案。
24页-新校区智慧校园综合布线建设方案.pdf
09-30
# 高校智慧校园解决方案摘要 智慧校园解决方案是针对高校信息化建设的核心工程，旨在通过物联网技术实现数字化校园的智能化升级。该方案通过融合计算机技术、网络通信技术、数据库技术和IC卡识别技术，初步实现了校园一卡通系统，进而通过人脸识别技术实现了更精准的校园安全管理、生活管理、教务管理和资源管理。 方案包括多个管理系统：智慧校园管理平台、一卡通卡务管理系统、一卡通人脸库管理平台、智能人脸识别消费管理系统、疫情防控管理系统、人脸识别无感识别管理系统、会议签到管理系统、人脸识别通道管理系统和图书馆对接管理系统。这些系统共同构成了智慧校园的信息化基础，通过统一数据库和操作平台，实现了数据共享和信息一致性。 智能人脸识别消费管理系统通过人脸识别终端，在无需接触的情况下快速完成消费支付过程，提升了校园服务效率。疫情防控管理系统利用热成像测温技术、视频智能分析等手段，实现了对校园人员体温监测和疫情信息实时上报，提高了校园公共卫生事件的预防和控制能力。 会议签到管理系统和人脸识别通道管理系统均基于人脸识别技术，实现了会议的快速签到和图书馆等场所的高效通行管理。与图书馆对接管理系统实现了一卡通系统与图书馆管理系统的无缝集成，提升了图书借阅的便捷性。 总体而言，该智慧校园解决方案通过集成的信息化管理系统，提升了校园管理的智能化水平，优化了校园生活体验，增强了校园安全，并提高了教学和科研的效率。
非标专机.zip
最新发布
09-30
非标专机.zip
基于asp.net的本科生考勤与考核管理系统设计与实现.docx
09-30
基于asp.net的本科生考勤与考核管理系统设计与实现.docx
1代一拖二口罩机-三维3D设计图纸.zip
09-30
1代一拖二口罩机_三维3D设计图纸.zip
Java多线程基础与实践指南
Java多线程学习笔记主要涵盖了线程在Java编程中的核心概念和操作。首先，让我们深入了解线程的基本概念。在Java中，线程是程序执行的基本单元，它允许并发执行多个任务，从而提高程序的效率。线程通过继承`java.lang...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值