初识java多线程

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

一、创建多线程的方法一：

创建java.lang.Thread的子类，重写该类的run方法

基本用法例子：

public class ThreadTest1 {
  public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 1、创建一个线程对象
        Thread thr = new FirstThread(); 
        // 2、调用线程对象的start（）方法启动线程
        thr.start();
        String threadName = Thread.currentThread().getName();
            for (int i = 0; i < 100; i++){
                System.out.println(threadName + ": " + i);
            }
    }
}
//继承Thread类
class FirstThread extends Thread{
/*
* 线程体在run（）方法中
*/
public void run(){
    // 显示当前线程名称
    String threadName = Thread.currentThread().getName();
        for (int i = 0; i < 100; i++){
        System.out.println(threadName + ": " + i);
        }
    }
}
//输出结果为：
main: 0
Thread-0: 0
Thread-0: 1
main: 1
main: 2
Thread-0: 2
main: 3
Thread-0: 3
Thread-0: 4
...
0~99 输出了两遍


思考一下如何去实现两个线程共享一个变量？
1. 思路一:是用static静态化一个变量


public class PrintNumber {
   public static void main(String[] args){
       Thread thread1 = new PrintThread("thread1");
       Thread thread2 = new PrintThread("thread2");
       thread1.start();
       thread2.start();
   }
}
class PrintThread extends Thread{
   private static int i;
   public PrintThread(String name){
       super(name);
   }
   public void run(){
       for (i = 0; i < 100; i++){
          System.out.println(getName() + ": " + i );
       }
   }
}

2.思路二： 传递一个对象给一个进程，通过对象在进程中共享数据


public class PrintNumber {
   public int i;
   public static void main(String[] args){
       PrintNumber pn1 = new PrintNumber();// 需要传递给进程的对象
       Thread thread1 = new PrintThread("thread1", pn1);
       Thread thread2 = new PrintThread("thread2", pn1);
       thread1.start();
       thread2.start();
   }
}
class PrintThread extends Thread{
   PrintNumber pn;
   public PrintThread(String name, PrintNumber pn){
       super(name);
       this.pn = pn;
   }
   public void run(){
       for (pn.i = 0; pn.i < 100; pn.i++){
          System.out.println(getName() + ": " + pn.i );
       }
   }
}



二、创建多线程的方法二：

实现Runnable接口的方式：

1、创建实现Runnable接口的实现类：必须实现run（）方法

2、创建第一步那个实现类的实例对象
3、利用Thread（Runnable target）构造器，创建Thread对象

4、调用Thread类的start方法调用线程

例子：

//实现MyRunnbale是Runnable的实现类
public class MyRunnable implements Runnable {
    public static int i = 0;
    @Override
    // 实现run方法
    public void run() {
        for (; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + ":  " + i);
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyRunnable mr = new MyRunnable();
        Thread th1 = new Thread(mr);
        Thread th2 = new Thread(mr);
        th1.start();
        th2.start();
    }
}



三、线程的生命周期

线程的生命周期指的是线程从启动，直到结束
可以调用Thread类的相关方法影响线程的运行状态

线程的运行状态有：

  • 新建（new）
  • 可执行（Runnable）
  • 运行（Running）
  • 阻塞（Blocking）
  • 死亡（Dead）

新建状态

当新建了一个Thread对象时，该进程处于新建状态，没有启动，所以无法执行

可执行状态

其他线程调用了处于新建状态线程的start方法，该线程对象转换到“可执行状态”
线程拥有获得cpu的权利，处于等待调度阶段

运行状态

处于可执行状态的线程一旦获得cpu的控制权，就会转换到运行状态，
在执行状态下，线程状态占用cpu时间片段，执行run方法中的代码，处于执行状态下的线程可以调用yield方法，该方法用于主动让出cpu控制权。线程对象让出控制权后，回到可执行状态，重新等待调度；

阻塞状态

线程在执行状态下，由于某种条件影响，会被迫让出cpu控制权，进入“阻塞状态”
进入阻塞状态有三种情况：
- 调用sleep 方法：
Thread的sleep方法能让线程暂止休眠一段时间，单位是毫秒


实际例子：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + ":  " + i);
            try {
                // Thread的sleep方法能让线程暂止休眠一段时间，单位是毫秒

                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyRunnable mr = new MyRunnable();
        Thread th1 = new Thread(mr);
        th1.start();
    }
}
  • 调用join方法
    处于执行状态的调用了其他线程的join方法，将会挂起，进入阻塞状态
    目标线程执行完毕后，才能解除阻塞，回到可执行状态；

public class ThreadJoin extends Thread{
    public void run(){
        for (int i = 0; i < 10; i++){
            System.out.println(getName() + ": " + i);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadJoin thread = new ThreadJoin();
        thread.start();
        for (int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + ": " + i);
            if (i == 5){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}
// 输出结果；
main: 0
Thread-0: 0
main: 1
main: 2
Thread-0: 1
main: 3
main: 4
Thread-0: 2
main: 5
Thread-0: 3
Thread-0: 4
Thread-0: 5
Thread-0: 6
Thread-0: 7
Thread-0: 8
Thread-0: 9
main: 6
main: 7
main: 8
main: 9

  • 执行I/O操作



    解除阻塞状态有三种情况：

  • 睡眠超时
  • 调用join后等待其他线程执行完毕
  • I／O操作完毕
  • 调用堵塞线程的interrupter方法（线程睡眠时，调用该方法会抛出InterrupterException） 

public class Interrupter extends Thread {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Interrupter interrupter = new Interrupter();
        interrupter.start();
        interrupter.interrupt(); //解除线程的堵塞状态
    }

    public void run(){
        for (int i = 0; i < 10; i++){
            System.out.println(getName() + ": " + i);
            if (i == 5){
                try {
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}
执行结果：
Thread-0: 0
Thread-0: 1
Thread-0: 2
Thread-0: 3
Thread-0: 4
Thread-0: 5
java.lang.InterruptedException: sleep interrupted //这是提示运行时异常
Thread-0: 6
Thread-0: 7
Thread-0: 8
Thread-0: 9
    at java.lang.Thread.sleep(Native Method)
    at Interrupter.run(Interrupter.java:15)



死亡状态

处于执行状态的线程一旦从run（）方法返回，无论是正常退出还是抛出异常，就会进入“死亡状态”；

已经死亡的线程不能重新运行，否则会抛出异常illegalThreadStateException

可以使用Thread类的isAlive方法判断线程是否活着；



四、线程的优先级

  • Thread类提供了设置和获取当前优先级的方法:

    setPriority();设置优先级不一定起作用，在不同的JVM、操作系统上，效果不同，操作系统不能保证设置了优先级的线程会优先执行或者获得更多的cpu时间

    getPriority();
  • Java设置了10个优先级，1～10；1最低，10最高，主线程默认优先级为5；
  • 三个代表优先级的常量：MIN_PRIORITY、MAX_PRIORITY、NORM_PRIORITY,分别代表1、10、5

public class PriortityTest extends Thread{
    public PriortityTest(String name) {
        // TODO Auto-generated constructor stub
        super(name);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        PriortityTest priThread0 = new PriortityTest("线程一"),
                      priThread1 = new PriortityTest("线程二1");
        System.out.println(priThread0.getPriority());// 5
        System.out.println(priThread1.getPriority());// 5
        priThread0.setPriority(MIN_PRIORITY);//值为10，The maximum priority that a thread can have.
        priThread1.setPriority(MAX_PRIORITY);
        priThread0.start();
        priThread1.start();
    }
    public void run(){
        for (int i = 0; i < 10; i++){
            System.out.println(getName() + ": " + i);
        }
    }
}



五、线程共享以及安全问题：

首先来看个例子：有五个苹果，两个线程同时拿苹果，每拿一个，打印谁拿了，剩下几个； 利用多线程，两个线程共享资源appleCount，这样在其中一个线程拿完一个苹果后，还没来的及打印，第二个线程已经将appCount－－；所以会导致打印剩下的苹果时出现错位；


public class ShareApple implements Runnable{
    private int appleCount = 5;
    boolean getApple(){
        if (appleCount > 0){
            appleCount--;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿走一个苹果," + "剩" + appleCount);
            return true;
        }
        return false;
    }
    public void run(){
        boolean flag = getApple();
        while (flag){

          flag = getApple();
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
       ShareApple sa = new ShareApple(); 
       Thread th1 = new Thread(sa);
       Thread th2 = new Thread(sa);
       th1.setName("shao");
       th2.setName("jinghong");
       th1.start();
       th2.start();
    }
}

//输出结果为：
shao拿走一个苹果,剩3
jinghong拿走一个苹果,剩3
shao拿走一个苹果,剩1
jinghong拿走一个苹果,剩1
shao拿走一个苹果,剩0


使用synchronized代码块解决线程安全问题

需要在synchronized代码块参照线程共同的对象：

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 

synchornized(){
    //...
}
  1. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 
public synchronized void method(){
    // ...
}
  1. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 
public synchronized static void method() {
   // todo
}
  1. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。
class ClassName {
   public void method() {
      synchronized(ClassName.class) {
         // todo
      }
   }
}

synchronized关键字，确保共享资源只能在同一个时刻被一个线程访问，这种处理机制称为线程同步，或者线程互斥，基于“对象锁”的概念


public class ShareApple implements Runnable{
    private int appleCount = 5;
    boolean getApple(){
        synchronized(this){
            // this是一个共同的参照对象，这里指的是同一个ShareApple对象
            if (appleCount > 0){
                appleCount--;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "拿走一个苹果," + "剩" + appleCount);
                return true;
            }
            return false;
        }
    }
    public void run(){
        boolean flag = getApple();
        while (flag){
          flag = getApple();
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
       ShareApple sa = new ShareApple(); 
       Thread th1 = new Thread(sa);
       Thread th2 = new Thread(sa);
       th2.setName("shao");
       th1.setName("jinghong");
       th1.start();
       th2.start();
    }
}



线程通信

当一个线程在使用同步方法的某个参数时，而此变量又需要其他线程修改后才能符合本线程的需要，那么可以在线程中添加wait（）方法；

相关方法：wait(), notify(), notifyAll();
这些方法必须在同步方法中调用。

例如：有如下情景，刘关张三个买票，售货员只有一张5元，张飞拿20元，刘备、关羽各拿五元，当张飞买票时，售货员会说：”没有足够多的零钱，需要等待后面的人买票后有零钱之后才能把票卖给你”；


public class Ticket implements Runnable{


    private int fiveCount = 1, tenCount = 0, twentyCount = 0;

    public synchronized void buy(){
        String name = Thread.currentThread().getName();
        if ("张飞".equals(name)){
           if (fiveCount < 3){
            try {
                System.out.println("没有足够多的零钱，需要等待有零钱之后才能把票卖给张飞");
                wait();
                System.out.println("卖给张飞一张票，并给他找零");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
           }
        } else if ("关羽".equals(name)){
            System.out.println("关羽给售票员一张五元");
            fiveCount ++; //关羽给售票员一张五元
        } else if("刘备".equals(name)){
            System.out.println("刘备给售票员一张五元");
            fiveCount ++;// 刘备给售票员一张五元
        }
        // 唤醒进程的条件
        if (fiveCount == 3){
            notifyAll();
        }
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        buy();
    }
    public static void main(String[] args){
        Ticket ticket = new Ticket();
        Thread th1 = new Thread(ticket);
        Thread th2 = new Thread(ticket);
        Thread th3 = new Thread(ticket);
        th1.setName("张飞");
        th2.setName("关羽");
        th3.setName("刘备");
        th1.start();
        th2.start();
        th3.start();
    }
}

//输出结果为：
没有足够多的零钱，需要等待有零钱之后才能把票卖给张飞
刘备给售票员一张五元
关羽给售票员一张五元
卖给张飞一张票，并给他找零


两个线程如何交替打印a－z


public class TrigglePrint implements Runnable{
    char c = 'a';
    public synchronized void  print(){
          System.out.println(Thread.currentThread().getName() + ": " + c);
          notifyAll();
          try {
            wait();
          } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          }
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (; c < 'z'; c++){
         print();
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TrigglePrint tp = new TrigglePrint();
        Thread thread1 = new Thread(tp);
        Thread thread2 = new Thread(tp);
        thread1.start();
        thread2.start();
    }
}
//结果：
Thread-0: a
Thread-1: a
Thread-0: b
Thread-1: c
Thread-0: d
Thread-1: e
Thread-0: f
Thread-1: g
Thread-0: h
Thread-1: i
Thread-0: j
...
...
初识java多线程 （java多线程基础知识汇总）
无名氏灬的博客
07-26 602
线程Thread 首先明确： 1.了解进程与线程之间的概念 2.线程的好处 3.创建线程 4.线程的操作 5.线程的缺点，如何防范。 =========================================== 一、概念    1. 进程与线程       a. 进程---就是正在进行的程序。          CPU在某一时间段只处理一个程序。 程序
多线程-进程、线程、多线程实现方式一：thread类、线程调度、线程控制、生命周期；二：实现Runnable接口；线程安全解决：同步代码块、同步方法；lock锁；线程通信；线程组、线程池、定时器
qq_39497997的博客
02-03 883
多线程-进程、线程、多线程实现方式一：thread类、线程调度、线程控制、生命周期；二：实现Runnable接口；线程安全解决：同步代码块、同步方法；lock锁；线程通信；线程组、线程池、定时器
Java笔记 - 黑马程序员_07(多线程，线程同步，线程池，网络编程入门，UDP通信原理，TCP通信原理，commons-io工具类）
逸乐的博客
05-17 930
1. 实现多线程 1.1 进程 进程：是正在运行的程序 是系统进行资源分配郑调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 举例： 记事本程序 扫雷程序 1.3 多线程的实现方式(方式1) 方式1：继承Thread类 定义一个类MyThread继承Thread类 在MyThread类中重写run()方法 创建MyT
11、多线程
qq_42263859的博客
07-07 1002
多线程的使用
创建线程的方式
wz122330的博客
03-07 278
初识java多线程概述初识多线程线程的两种创建方式多线程会出现的线程不安全问题认识synchronized和volatile关键字java线程抽象内存模型volatile关键字的作用synchronized关键字的作用volatile关键字和synchronized关键字的区别 概述 马老师多线程视频学习总结（好记性不如烂笔头）。 初识多线程 线程的两种创建方式 继承Thread类和实现Runna...
初识Java多线程
qq_37354060的博客
06-05 897
初识Java多线程进程与线程Java创建多线程ThreadRunnable 进程与线程 进程包含线程 进程是系统分配资源的最小单位，线程是系统调度的最小单位，一个进程内的线程之间可以共享资源 Java创建多线程 Thread Runnable ...
初识java多线程技术
m0_46550452的博客
07-08 237
一.进程与线程概述 进程可以直接理解为运行的程序，一个进程可以执行多个线程，线程依赖于进程。 注意：多进程计算机并不意味着CPU可以同时执行多个任务。事实上，多进程计算机是通过对程序的不断高效切换来让我们感觉CPU是在同时执行多个任务的。 线程分为单线程和多线程。多线程即意味着程序有多条路径去执行同一个任务。多线程的本质其实就是为了有更多的机会去获得CPU的执行权。也正是因为这个特点，多线程会存在线程安全问题。多线程的存在，不是为了提高程序的执行速度，而是为了提高应用程序的使用率。 二.多线程的实现方式 1
Java多线程的初识与简单的安全问题解决
01-20
多线程 目录 进程 进程的了解 线程 什么是线程 线程的组成 线程的创建 线程的状态 线程的方法 线程的安全问题 1.进程 1.1.进程的了解 简单的来说进程就是运行中的程序，简称为进程。 单核CPU在任意一个时间节点上，...
java线程多用户_Socket初识-多线程实现多用户登录
weixin_42511080的博客
02-26 674
1、ServerSocketpackage com.video.video.common;import java.io.*;import java.net.ServerSocket;import java.net.Socket;/*** 基于TCP协议的Socket通信，实现用户登录* 服务器端*/public class Server {public static void main(Strin...
Java线程初识
12-22
应用程序中可以同时执行多个功能 ==> 多线程 线程使用的是系统资源，该系统资源你是操作系统分配给当前进程使用的。 多个线程的情况下，同时【抢占执行】会导致资源紧缺。 线程抢占过程就类似于进
java多线程相关面试题 1
08-08
Java 多线程相关面试题总结 Java 多线程相关面试题是一组常见的 Java 面试题，涵盖了 Java 多线程编程的基础知识和高级概念。本文将对这些问题进行详细的解释和分析，帮助读者更好地理解 Java 多线程编程。 1. 为...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 192
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 296
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 290
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 475
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 302
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
shangan_3的博客
11-08 216
【代码】JAVA学习接口案例实例。
Java多线程编程详解
1. **初识Java多线程** Java中的线程可以通过继承`Thread`类或实现`Runnable`接口来创建。在提供的代码示例中，`ManyThread`类扩展了`Thread`类，创建了两个线程实例`t1`和`t2`。每个线程都有自己的`run()`方法，当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值