Java多线程(上)

已于 2022-03-23 22:30:04 修改
阅读量544 收藏
点赞数 1
分类专栏： java基础高级部分 文章标签： java
于 2022-03-23 22:24:21 首次发布
shenyi
本文链接：https://blog.csdn.net/m0_45279562/article/details/123698168
版权

Java多线程（上）

文章目录

1.认识线程和进程

  • 什么是线程

    • 线程就是程序执行的一条路径，例如QQ，同时多个窗口聊天。

  • 什么是进程

    • 进程是程序的一次动态执行过程，例如你用电脑打开QQ。

  • 线程与进程之间的关系

    • 一个进程可以包含多条进程，例如你打开QQ应用是开启了一个进程，使用QQ开启多个聊天窗口聊天相当于开启了多条线程。

  • 多线程

    • 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。
    • 多进程是指操作系统能同时运行多个任务（程序）。
    • 多线程是指在同一程序中有多个顺序流在执行。

2.线程实现的两种方式以及区别

继承Thread方法实现线程

public static void main(String[]args){
	MyThread mt=new MyThread();//4.创建Thread类的子类
	mt.start();//5.开启线程
    for(int i=0;i<1000;i++){
        System.out.println("bb");
    }
}
}

class MyThread extends Thread{//1.继承Thread
	public void run(){//2.重写run方法
		for(int i=0;i<1000;i++){//3.将要执行的代码写在run方法里
			System.out.println("aaaaaaaaa");
		}
	}
}

调用Runnable接口实现线程

public class Demo4_Ticket {
    public static void main(String[] args) {
        MyTicket mt=new MyTicket();//创建线程对象。
        new Thread(mt).start();//执行线程。
    }
}

class MyTicket implements Runnable{//继承Runnable接口
    @Override
    public void run() {
       //在这里写线程执行的代码。
    }
}

Thread方法和Runnable接口实现线程的区别

  • 继承Thread类

    • 优点：可以直接使用Thread类中的方法，代码简单。
    • 弊端：如果已经有了父类，则不能使用，不适合资源共享。

  • 实现Runnable接口

    • 优点：即使有了父类也可以实现接口，而且接口是可以多实现的，代码可以被多个线程共享。

    • 弊端：不能直接使用Thread中的方法，需要先获取线程对象后，才能得到Thread的方法，代码复杂。

3.匿名内部类创建线程的方法

//匿名内部类创建线程方法一
new Thread(){//1.继承Thread类
	@Override
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println("aaa");
		}
	}
}.start();


//匿名内部类创建线程方法二
new Thread(new Runnable(){//1.将runnnable的子类对象传递给Thread构造函数
@Override
public void run(){//2.重写run方法
	for(int i=0;i<1000;i++){
	System.out.println("bbbbbbbb");
	}
}
}).start();//3.开启线程

获取，更改线程名称

//获取线程名称
        new Thread("小胖一号"){
            @Override
            public void run() {
                System.out.println(this.getName());
            }
        }.start();

设置线程名称：
 //方法一
        new Thread("小胖一号"){
            @Override
            public void run() {
                this.setName("NOE");
                System.out.println(this.getName());
            }
        }.start();


        //方法二
        Thread t1=new Thread(){
            @Override
            public void run() {
                System.out.println(this.getName());
            }
        };

        t1.setName("TWO");
        t1.start();

4.线程状态转换

​ 先理解一下线程的五种状态，下图中运行和运行中是一种状态。

在这里插入图片描述

  • 睡眠线程：Thread.sleep(1000)//括号中的单位是毫秒。
	new Thread(){
        @Override
        public void run() {
            for (int i = 1;; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("小胖,胖了"+i+"圈");
            }
        }
    }.start();
  • 守护线程：setDeamon(true)设置该线程为守护线程，守护线程不会单独执行，非守护线程都执行完毕时，自动退出。
	Thread t1=new Thread(){
	            @Override
	            public void run() {
	                for (int i = 0; i < 2; i++) {
	                    System.out.println(getName()+"aaaaaaaaaaaaaaaaaaa");
	                }
	            }
	        };
	
	        Thread t2=new Thread(){
	            @Override
	            public void run() {
	                for (int i = 0; i < 50; i++) {
	                    System.out.println(getName()+"bbbb");
	                }
	            }
	        };
	
	        t2.setDaemon(true);
	        t1.start();
	        t2.start();
  • 加入线程：join（） 插队执行，先执行插入的线程，再执行其他线程
	Thread t1=new Thread(){
	            @Override
	            public void run() {
	                for (int i = 0; i <10 ; i++) {
	                    System.out.println("aaaaaaaaaa");
	                }
	            }
	        };
	
	        Thread t2=new Thread(){
	            @Override
	            public void run() {
	                for (int i = 0; i <10 ; i++) {
	                    if (i==2){
	                        try {
	                            // t1.join();     插队执行，先执行插入的线程，再执行其他线程
	                            t1.join(1);//插队指定的时间，超过指定的后，线程交替执行
	                        } catch (InterruptedException e) {
	                            e.printStackTrace();
	                        }
	                    }
	                    System.out.println("bb");
	                }
	            }
	        };
	
	        t1.start();
	        t2.start();

  • 礼让线程：yieId()礼让线程，哪个线程调用，那该线程则让出CPU。

  • 设置线程的优先级：线程名.setPriority(10);//设置线程执行的优先级，优先级为1~10，10的优先级最高

    
Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("aaaaaa");
                }
            }
        };


        Thread t2=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("bb");
                }
            }
        };
        t1.setPriority(10);//设置线程执行的优先级，优先级为1~10，10的优先级最高
        t1.start();
        t2.start();

  • 线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。

5.同步代码块

  • 1.什么情况下需要同步
    • 当多线程并发，有多段代码执行时，我们希望某一段代码执行的过程中CPU不要切换到其他线程工作，这时就需要同步
    • 如果两段代码是同步的，那么同一时间只能执行一段代码，在这一段代码执行结束之前，不会执行另外一段代码。
  • 2.同步代码块
    • 使用Synchronized关键字加上一个锁对象来定义一段代码，这就是同步代码块。
    • 多个同步代码块如果使用的是相同的锁对象，那么他们就是同步的。
//其中锁的对象要是同一个。
public class Synchronized {
    /*
        同步代码块
     */
    public static void main(String[] args) {
       Printer p=new Printer();

       new Thread(){
           @Override
           public void run() {
               while(true){
                   p.print1();
               }
           }
       }.start();

        new Thread(){
            @Override
            public void run() {
                while(true){
                    p.print2();
                }
            }
        }.start();

    }
}

class Printer{
    demo d=new demo();                //同步代码块，锁机制，对象可以是任意的
    public void print1(){
        synchronized (d){
            System.out.print("黑");
            System.out.print("马");
            System.out.println();
        }

    }
    public void print2(){              //同步代码块，不能用匿名对象，因为不是同一个对象，锁不同
        synchronized(d){
            System.out.print("1");
            System.out.print("2");
            System.out.print("3");
            System.out.print("4");
            System.out.print("5");
            System.out.print("6");
            System.out.print("7");
            System.out.print("8");
            System.out.println();
        }

    }
}

6.同步方法

使用synchronized关键字修饰的一个方法，该方法中所有的代码都是同步的。

public class Synchronized {
    /*
        同步代码块
     */
    public static void main(String[] args) {
       Printer p=new Printer();
       new Thread(){
           @Override
           public void run() {
               while(true){
                   p.print1();
               }
           }
       }.start();

        new Thread(){
            @Override
            public void run() {
                while(true){
                    p.print2();
                }
            }
        }.start();

    }
}

class Printer{
    demo d=new demo();                //同步方法只用在方法上加synchronized关键字
    //非静态同步方法的锁对象是什么？
    //答：非静态的同步方法的锁对象是this

    //静态的同步方法的锁对象是什么？
    //是该类的字节码对象。
    public static synchronized void print1(){

            System.out.print("黑");
            System.out.print("马");
            System.out.println();


    }
    public static void print2(){              //
        synchronized(Printer.class){
           System.out.print("1");
            System.out.print("2");
            System.out.print("3");
            System.out.print("4");
            System.out.print("5");
            System.out.print("6");
            System.out.print("7");
            System.out.print("8");
            System.out.println();
        }
    }
}

7.线程安全问题

实例：

方法一：使用继承Thread，实现线程

public class Demo3_Ticket {
    public static void main(String[] args) {
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
    }
}

class Ticket extends Thread{
    private static int ticket=100;
    public void run(){
        while(true){
            synchronized(Ticket.class){//Ticket的字节码对象
                if (ticket==0){
                    break;
                }
                System.out.println(getName()+"...这是第"+ticket--+"张票");
            }

        }
    }

}

方法二：使用Runnable接口，实现线程

public class Demo4_Ticket {
    public static void main(String[] args) {
        MyTicket mt=new MyTicket();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();

//        Thread t1=new Thread(mt);         多次启动线程是非法的
//        t1.start();
//        t1.start();
//        t1.start();
//        t1.start();
    }
}

class MyTicket implements Runnable{
    private int tickets=100;

    @Override
    public void run() {
        while(true){
            synchronized(this){
                if (tickets<=0){
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"...这是第"+tickets--+"张票");
            }
        }
    }
}

8.死锁实例

避免死锁的发生，Synchronized最好不要嵌套

public class Demo5 {

    private static  String s1="筷子左";
    private static  String s2="筷子右";

    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                while(true){
                    synchronized (s1){
                        System.out.println("获取"+s1+"等待"+s2);
                        synchronized (s2){
                            System.out.println("拿到"+s2+"开吃");
                        }
                    }
                }

            }
        }.start();


        new Thread(){
            @Override
            public void run() {
                while(true){
                    synchronized (s2){
                        System.out.println(getName()+"...获取"+s2+"等待"+s1);
                        synchronized (s1){
                            System.out.println("拿到"+s1+"开吃");
                        }
                    }
                }

            }
       }.start();

	  new Thread(){
	            @Override
	            public void run() {
	                while(true){
	                    synchronized (s2){
	                        System.out.println(getName()+"...获取"+s2+"等待"+s1);
	                        synchronized (s1){
	                            System.out.println("拿到"+s1+"开吃");
	                        }
	                    }
	                }
	
	            }
	        }.start();
	    }
}
Java小羽
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程（一）
友桥的博客
07-11 135
一、JAVA线程实现/创建方式 （1） 继承 Thread 类 Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方 法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线 程，并执行run()方法 public class MyThread exten...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 16万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1090
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 766
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 739
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1310
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
java算法day19
TOMOT77的博客
07-20 302
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
springboot之自动装配
weixin_50153914的博客
07-23 220
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1189
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 950
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
[Jenkins]jenkins-cli.jar调用用户token启动任务
最新发布
China_Yanhy的博客
07-23 523
jenkins-cli.jar调用用户token启动任务
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 799
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
java 多线程上锁
08-08
在 Java 中，可以使用关键字 `synchronized` 来对多线程进行上锁。 在使用 `synchronized` 时，可以有两种方式来实现多线程的上锁： 1. 对方法进行上锁：可以在方法的声明处使用 `synchronized` 关键字，这样当一个线程进入该方法时，其他线程将被阻塞，直到该线程执行完该方法并释放锁。 例如： ```java public synchronized void myMethod() { // 方法体 } ``` 2. 对代码块进行上锁：可以通过创建一个对象来作为锁，并使用 `synchronized` 关键字来对代码块进行上锁。这样只有持有同一个锁对象的线程才能执行该代码块，其他线程将被阻塞。 例如： ```java Object lock = new Object(); synchronized (lock) { // 代码块 } ``` 这样可以确保在多个线程同时访问共享资源时，只有一个线程能够执行相关代码，从而避免了竞态条件和数据不一致的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值