java线程

最新推荐文章于 2024-11-13 20:43:20 发布
最新推荐文章于 2024-11-13 20:43:20 发布
阅读量173 收藏 1
点赞数
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/penghaixia666/article/details/125820831
版权
本文详细介绍了Java线程的概念，包括线程与进程的关系、线程的创建（通过Thread类、Runnable接口和Callable接口）、常用方法、线程状态转换以及线程安全问题。此外，还讨论了多线程的使用场景、并发与并行的区别，并提供了线程同步的实例，如synchronized和Lock锁的使用。最后，通过生产者消费者模型展示了线程通信的实现。
摘要由CSDN通过智能技术生成

目录

线程

线程和进程的关系

线程中的常用方法

创建线程的三种方式

常用方法

线程状态

新建

就绪

运行

阻塞

死亡

守护线程

多线程

什么时候用到多线程

多线程的优点

并发

并行

线程安全

解决

线程通信

线程

线程和进程的关系

进程是操作系统分配资源的最小单位

线程是一个进程内部的最小执行单元

1.一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程而独立运行

2.每一个进程至少包含一个线程(称为主线程)，在主线程中开始执行程序， java程序的入口main()方法就是在主线程中被执行的。

3.在主线程中可以创建并启动其它的线程， 一个进程内的所有线程共享该进程的内存资源

线程中的常用方法

创建线程的三种方式

1.继承Thread类

示例

public class MyThread extends Thread {
    @Override
    public void run() {
        /*
         在线程中要执行的任务全部写在run方法中
         Thread类是java中提供对线程进行管理的类
        */
        for (int i = 0; i <1000 ; i++) {
            System.out.println("第"+i+"次");
        }
     }
}
public class Demo1 {
    public static void main(String[] args) {
        System.out.println("main方法开始");
        //创建线程
        MyThread myThread=new MyThread();
        myThread.start();//启动线程
        System.out.println("main方法结束");
    }
}

2.实现Runnable接口

实现Runnable的好处 1.避免了单继承的局限性 2.多个线程可以共享同一个接口实现类的对象，适合多个相同线程来处 理同一份资源

示例

public class Test implements Runnable{
/*
   线程任务类
*/
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"第"+i+"次");
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Test test=new Test();
        Thread thread=new Thread(test);//创建线程
        thread.start();
        Thread thread1=new Thread(test);//创建线程
        thread1.start();
    }
}

3.实现Callable接口

1.call（）方法相比run（）方法，可以有返回值

2.方法可以抛出异常

3.支持泛型的返回值

4.需要借助FutureTask类，获取返回结

示例

import java.util.concurrent.Callable;
​
public class Sum implements Callable<Integer> {
    /*
      线程的第三种创建方式
​
    */
    @Override
    public Integer call() throws Exception {
        int i=0;
        for (int j = 0; j < 10; j++) {
            i+=j;
        }
        return i;
    }
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
​
public class Test {
    public static void main(String[] args) {
        Sum sum=new Sum();
        FutureTask<Integer> futureTask=new FutureTask(sum);//接收任务
        Thread thread=new Thread(futureTask);//创建线程
        thread.start();//开启线程
        try {
            Integer i=futureTask.get();//接收返回值
            System.out.println(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
​
    }
}

常用方法

setPriority(int):设置线程的优先级别，可选范围1-10，默认为5

static sleep(long):让当前的线程休眠并且指定毫秒数

static yield();线程主动让步,让出CPU的执行权.可以直接进入就绪队列中

join()：线程让步

run()线程任务执行的方法，在线程中要执行的任务

start()启动线程

currentThread()获取当前线程(静态)

getName() 获取线程名字

getPrionty()获取优先级

setName() 设置线程名字

线程状态

新建

当一个Thread类或其子类的对象被声明并创建时，新生的线程对 象处于新建状态

就绪

处于新建状态的线程被start（）后，将进入线程队列等待CPU时 间片，此时它已具备了运行的条件，只是没分配到CPU资源

运行

当就绪的线程被调度并获得CPU资源时，便进入运行状态，run （）方法定义了线程的操作和功能

阻塞

在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态

死亡

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

守护线程

只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。

示例：

public class DaemonTest {
    public static void main(String[] args) {
        Demo demo=new Demo();
        DaemonThread daemonThread=new DaemonThread();
        demo.start();
        daemonThread.setDaemon(true);//设置为守护线程
        daemonThread.start();
    }
}
​
public class DaemonThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <10000 ; i++) {
            System.out.println("守护线程");
        }
    }
}
​
public class Demo extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println(i);
        }
    }
}
​

多线程

什么时候用到多线程

1.程序需要同时执行两个或多个任务。 2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、 网络操作、搜索等。

多线程的优点

  1. 提高程序的响应.

  2. 提高CPU的利用率. ，压榨硬件的价值

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

并发

在同一个时间点上，多个事情依次发生

并行

在同一个时间段内，多个事情同时执行

线程安全

多个线程用同一个资源

解决

排队+锁

1.几个线程之间要排队，一个个对共享资源进行操作，而不是同时进行操作； 2.为了保证数据在方法中被访问时的正确性，在访问时加入锁机制

synchronized锁

1.是一个关键字

2.可以修饰代码块和方法

3.隐式锁同步代码块执行完毕或者出现异常会自动释放

4.修饰方法时,非静态:锁对象是this， 静态:锁对象是当前类的class对象

模拟售票：

1.实现接口

public class PrintTicket implements Runnable {
    int num = 10;
​
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + num);
                    num--;
                } else break;
            }
        }
    }
}
​
public class Test {
    public static void main(String[] args) {
        PrintTicket printTicket=new PrintTicket();
        Thread thread=new Thread(printTicket,"窗口1:");
        Thread thread1=new Thread(printTicket,"窗口2:");
        thread.start();
        thread1.start();
    }
}

2.继承Thread

public class Demo1 extends Thread{
    static int num=10;
    static Object object=new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (object) {
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + num--);
                }
                else break;
            }
        }
    }}
​
​
public class TestDemo1 {
    public static void main(String[] args) {
        Demo1 demo1=new Demo1();
        demo1.setName("窗口1:");
        Demo1 demo2=new Demo1();
        demo2.setName("窗口2:");
        demo1.start();
        demo2.start();
    }
}

Lock锁

1.是一个类

2.只能修饰方法块

3.要手动的添加释放锁

示例

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
​
public class Lock1 implements Runnable{
    int num=10;
    Lock lock=new ReentrantLock();
​
    @Override
    public void run() {
        while (true) {
             {
                 try {
                     lock.lock();//添加锁
                     if (num > 0) {
                         System.out.println(Thread.currentThread().getName() + num--);
                     }
                     else break;
                 }
                 finally {
                     lock.unlock();//释放锁
                 }
​
            }
        }
    }
}
​
​
public class LockTest1 {
    public static void main(String[] args) {
        Lock1 lock1=new Lock1();
        Thread thread=new Thread(lock1,"窗口1:");
        Thread thread1=new Thread(lock1,"窗口2:");
        thread.start();
        thread1.start();
    }
}

线程通信

线程通讯指的是多个线程通过相互牵制，相互调度，即线程间的相互作用

生产者消费者示例

//柜台：
public class Counter {
    int i=0;
    public synchronized void add(){
          while (true){
              if(i==0){
                  i=1;
                  System.out.println("生产者添加了一个");
                  this.notify();
              }else {
                  try {
                      this.wait();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
    }
    public synchronized void take(){
        while(true){
            if(i!=0){
                i=0;
                System.out.println("消费者用掉了一个");
                this.notify();
            }else {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}




//生产者
public class Productor extends Thread{
    Counter counter;

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

    @Override
    public void run() {
        counter.add();
    }
}


//消费者
public class Customer extends Thread {
    Counter counter;

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

    @Override
    public void run() {
        counter.take();
    }
}



//测试
public class Test {
    public static void main(String[] args) {
        Counter counter=new Counter();
        Productor productor=new Productor(counter);
        Customer customer=new Customer(counter);
        productor.start();
        customer.start();
    }
}

交替打印100之内的数

public class PrintDemo implements Runnable{
    int i=0;
    @Override
    public void run() {
           synchronized (this){

       while(true){
            this.notify();
            System.out.println(Thread.currentThread().getName()+":"+i++);
            if(i>=100){
                break;
            }
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
           }
    }
}

public class Test {
    public static void main(String[] args) {
        PrintDemo printDemo=new PrintDemo();
        Thread thread=new Thread(printDemo);
        Thread thread1=new Thread(printDemo);
        thread.start();
        thread1.start();
    }
}
山枧雾
关注
专栏目录
Java 线程
06-01
NULL 博文链接：https://yangeoo.iteye.com/blog/2219492
Java 线程状态、线程池
01-20
java 线程状态、线程池 1. java 的线程状态 状态 发生条件 NEW 线程刚刚被创建，没有启动，没有调用start方法 RUNNABLE(可运行) 线程已经在JVM中运行，但是是否运行不确定，看当前线程是否由CPU执行权 ...
Java学习_getProperty()方法初探
qq_37954619的博客
09-23 886
getProperty()方法大全 在学习java课程时，课本中有如下 java代码段： private static final String NEW_LINE = System.getProperty("line.separaror"); //系统的换行符 一直不明白line.separaror具体什么意思，于是在网上查了查有了相当丰富的答案： System.out.println(“java版本号：” + System.getProperty(“java.version”)); // java版本
JAVA线程
互联网底层民工的博客
06-26 1万+
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
02Java线程模型
爱丹丹的博客
11-20 1515
线程有哪几种实现方式？Java线程与操作系统线程之间又有什么关系呢？
探索Java线程副本技术：深入理解与实践ThreadLocal
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
05-01 5万+
ThreadLocal作为Java线程副本技术的核心实现，为多线程编程提供了强大的线程隔离能力。深入理解其工作原理、掌握正确的使用方法、关注潜在问题及最佳实践，将有助于开发者在复杂并发场景下编写高效、安全、易于维护的代码。
1、【java线程及线程池系列】java线程及线程池概念详解
热门推荐
alanchanchn的专栏
06-12 5万+
缓冲队列长度的设置，按照一般的理解应该设置成maximumPoolSize的5倍，因为单个线程在不切换cpu的情况下是单个cpu运算一个线程，corePoolSize设置成和cpu一样的数量，maximumPoolSize设置成cpu的2倍，避免cpu处于空闲状态则直接加入一旦cpu空闲理解执行的线程数量，同时由于cpu的速度较快以及有请求执行的线程加入缓冲队列中减少cpu等待时间，故将缓冲队列设置大一些。线程池存在的目的在于提前创建好需要的线程，减少临时创建线程带来的资源消耗。
Java线程
weixin_45736498的博客
01-23 160
线程 线程 是程序中的执行线程。 Java 虚拟机允许应用程序并发地运行多个执行线程。 每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个守护程序。当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。 实现线程 Thread类 Runnable接口 ...
Servlet的生命周期
最新发布
wyk的博客
11-13 974
Servlet 的生命周期包含四个主要阶段：加载与实例化、初始化、请求处理、销毁。开发者可以在这些生命周期方法中编写初始化、请求处理和资源清理的代码，确保 Web 应用程序的正常运行。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 276
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Java基础07
m0_74977981的博客
11-11 677
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
1112--接口
kequanrrr的博客
11-12 384
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 716
Rest请求处理
刷题---顺序表算法题
weixin_63997543的博客
11-11 434
顺序算法题----力扣刷题
JAVA学习接口案例实例
shangan_3的博客
11-08 241
【代码】JAVA学习接口案例实例。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 1320
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值