java多线程

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量62 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feng_xi_/article/details/119175234
版权

1、实现多线程

 

        1.1、进程

         1.2、线程

         

         1.3、多线程的第一种实现方式(第二种实现方式是1.8)

//测试类

public class Main {
    public static void main(String[] args){

        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();

        mt1.start();
        mt2.start();

    }
}

//MyThread类
public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(i);
        }
    }
}

        1.4、设置和获取线程名称 

 用set/get方法设置和获取线程名称

//测试类

public class Main {
    public static void main(String[] args){

        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();

        mt1.setName("飞机");
        mt2.setName("高铁");

        mt1.start();
        mt2.start();

    }
}

//MyThread类
public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

用构造方法设置和获取线程名称

//测试类

public class Main {
    public static void main(String[] args){

        MyThread mt1 = new MyThread("飞机");
        MyThread mt2 = new MyThread("高铁");

        mt1.start();
        mt2.start();

    }
}

//MyThread类

public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

获取main( )方法所在的线程名称

  System.out.println(Thread.currentThread().getName());   //main

        1.5、线程调度 

 java中的优先级

        System.out.println(Thread.MAX_PRIORITY);      //最高优先级是：10
        System.out.println(Thread.MIN_PRIORITY);      //最低优先级是：1
        System.out.println(Thread.NORM_PRIORITY);     //默认优先级是：5

设置和返回优先级的方法

//测试类

public class Main {
    public static void main(String[] args){

        MyThread mt1 = new MyThread("飞机");
        MyThread mt2 = new MyThread("高铁");
        MyThread mt3 = new MyThread("汽车");

        mt1.setPriority(10);
        mt2.setPriority(5);
        mt3.setPriority(1);

        mt1.start();
        mt2.start();
        mt3.start();

//        System.out.println(mt1.getPriority());      //10
//        System.out.println(mt2.getPriority());      //5
//        System.out.println(mt3.getPriority());      //1

    }
}

MyThread类

public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

        1.6线程控制 

 sleep( )方法

//测试类


public class Main {
    public static void main(String[] args){

        MyThread mt1 = new MyThread("飞机");
        MyThread mt2 = new MyThread("高铁");
        MyThread mt3 = new MyThread("汽车");

        mt1.start();
        mt2.start();
        mt3.start();

    }
}

//MyThread类

public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
            try {
                sleep(1000);    //1000ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

join方法

//测试类


public class Main {
    public static void main(String[] args) {

        MyThread mt1 = new MyThread("康熙");
        MyThread mt2 = new MyThread("四阿哥");
        MyThread mt3 = new MyThread("八阿哥");

        mt1.start();
        try {
            mt1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        mt2.start();
        mt3.start();

    }
}

//MyThread类

public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

setDaemon( )方法

//测试类

public class Main {
    public static void main(String[] args) {

        MyThread mt1 = new MyThread("关羽");
        MyThread mt2 = new MyThread("张飞");

        //设置主线程为刘备
        Thread.currentThread().setName("刘备");

        //设置守护线程
        mt1.setDaemon(true);
        mt2.setDaemon(true);

        mt1.start();
        mt2.start();

        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

    }
}

//MyThread类

public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

        1.7、线程的生命周期

        1.8、多线程的第二种实现方式(第一种实现方式是1.3)

//测试类

public class Main {
    public static void main(String[] args){
        //创建MyRunnable类的对象
        MyRunnable mr = new MyRunnable();

        //创建Thread对象，并把MyRunnable作为构造方法的参数传进去
//        Thread t1 = new Thread(mr);
//        Thread t2 = new Thread(mr);

        //创建Thread对象，并把MyRunnable作为构造方法的参数传进去，并为线程命名
        Thread t1 = new Thread(mr,"飞机");
        Thread t2 = new Thread(mr,"高铁");

        //启动线程
        t1.start();
        t2.start();
    }
}

//MyRunnable类
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

2、线程同步

        案例：卖票

//测试类

public class Main {
    public static void main(String[] args){
        //创建MyRunnable类的对象
        MyRunnable mr = new MyRunnable();

        //创建Thread对象，并把MyRunnable作为构造方法的参数传进去，并为线程命名
        Thread t1 = new Thread(mr,"窗口一");
        Thread t2 = new Thread(mr,"窗口二");
        Thread t3 = new Thread(mr,"窗口三");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

//MyRunnable类

public class MyRunnable implements Runnable{

    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            if(tickets > 0){
                System.out.println(Thread.currentThread().getName()+"正在卖第"+tickets+"张票");
                tickets --;
            }
        }
    }
}

        2.1、卖票案例的思考

        2.2、卖票问题的解决 

         2.3、同步代码块

//测试类


public class Main {
    public static void main(String[] args){
        //创建MyRunnable类的对象
        MyRunnable mr = new MyRunnable();

        //创建Thread对象，并把MyRunnable作为构造方法的参数传进去，并为线程命名
        Thread t1 = new Thread(mr,"窗口一");
        Thread t2 = new Thread(mr,"窗口二");
        Thread t3 = new Thread(mr,"窗口三");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

//MyRunnable类

public class MyRunnable implements Runnable{

    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + tickets + "张票");
                    tickets--;
                }
            }
        }
    }
}

        2.4、同步方法

//测试类


public class Main {
    public static void main(String[] args){
        //创建MyRunnable类的对象
        MyRunnable mr = new MyRunnable();

        //创建Thread对象，并把MyRunnable作为构造方法的参数传进去，并为线程命名
        Thread t1 = new Thread(mr,"窗口一");
        Thread t2 = new Thread(mr,"窗口二");
        Thread t3 = new Thread(mr,"窗口三");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

//同步方法：

//MyRunnable类

public class MyRunnable implements Runnable{

    private int tickets = 100;
    private int i = 0;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            if (i % 2 == 0) {
                synchronized (this) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (tickets > 0) {
                        System.out.println(Thread.currentThread().getName() + "正在卖第" + tickets + "张票");
                        tickets--;
                    }
                }
            }else {
                lock();
            }
            i ++;
        }
    }

    private synchronized void lock() {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "正在卖第" + tickets + "张票");
                tickets--;
            }
    }
}

 //同步静态方法：

//MyRunnable类

public class MyRunnable implements Runnable{

    private static int tickets = 100;
    private int i = 0;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            if (i % 2 == 0) {
                synchronized (MyRunnable.class) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (tickets > 0) {
                        System.out.println(Thread.currentThread().getName() + "正在卖第" + tickets + "张票");
                        tickets--;
                    }
                }
            }else {
                lock();
            }
            i ++;
        }
    }

    private static synchronized void lock() {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "正在卖第" + tickets + "张票");
                tickets--;
            }
    }
}

        2.5、线程安全的类 

// 创建线程安全类的对象

 //返回指定list、map、set支持的同步(线程安全) list、map、set

List<String> list = Collections.synchronizedList(new ArrayList<>());
Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
Set<String> set = Collections.synchronizedSet(new HashSet<>());

        2.6、Lock锁

//测试类

import java.util.*;

public class Main {
    public static void main(String[] args){
        //创建MyRunnable类的对象
        MyRunnable mr = new MyRunnable();

        //创建Thread对象，并把MyRunnable作为构造方法的参数传进去，并为线程命名
        Thread t1 = new Thread(mr,"窗口一");
        Thread t2 = new Thread(mr,"窗口二");
        Thread t3 = new Thread(mr,"窗口三");

        //启动线程
        t1.start();
        t2.start();
        t3.start();

    }
}

//MyRunnable类

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyRunnable implements Runnable{

    private int tickets = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + tickets + "张票");
                    tickets--;
                }
            }finally {
                lock.unlock();
            }
        }
    }
}

3、生产者与消费者

        3.1、生产者消费者模式概述

 生产者消费者案例：

//测试类

import java.util.*;

public class Main {
    public static void main(String[] args){

        Box b = new Box();

        Produce p = new Produce(b);
        Consumer c = new Consumer(b);

        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);

        t1.start();
        t2.start();
    }
}

//Produce类

public class Produce implements Runnable {

    private Box b;

    public Produce(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for(int i=1;i<=5;i++){
            b.put(i);
        }
    }
}
//Consumer类

public class Consumer implements Runnable{

    private Box b;

    public Consumer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}

//Box类

public class Box {
    private int milk;
    private boolean state = false;

    public synchronized void put(int milk){
        //如果有牛奶，等待消费
        if(state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶，执行生产牛奶操作
        this.milk = milk;
        System.out.println("生产者将第"+this.milk+"瓶奶放入奶箱");
        //生产牛奶完毕，修改标志位
        state = true;
        //唤醒等待的线程
        notifyAll();
    }

    public synchronized void get(){
        //如果没有牛奶，等待生产
        if(!state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，执行消费操作
        System.out.println("用户将第"+this.milk+"瓶奶拿走");
        //消费牛奶完毕，修改标志位
        state = false;
        //唤醒等待的线程
        notifyAll();
    }
}

待凤惜变优秀
关注
java多线程execute_Java多线程
weixin_34704521的博客
02-16 2730
Java多线程之Executor、ExecutorService、Executors、Callable、Future与FutureTask1. 引子初学Java多线程，常使用Thread与Runnable创建、启动线程。如下例:Thread t1 = new Thread(newRunnable() {@Overridepublic voidrun() {System.out.println(Th...
java多线程查询_java多线程查询
weixin_33370255的博客
02-20 3469
标签：由于最近工作遇到性能问题，尝试研究用多线程来实现，结果速度快了好几倍下面是多线程查询的部分代码，提供给大家参考下：线程类：带返回值的类要实现Callable接口，具体业务逻辑没有实现，只是写了个空方法在里面package com.sanfy.demo.thread;import java.util.List;import java.util.Map;import java.util.conc...
Java多线程详解
坏蛋阿土的博客
11-06 6618
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
Java 多线程编程基础(详细)
热门推荐
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
java多线程使用教程
鹏鹏2077
04-25 5443
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
Java 多线程 测试
风信子
04-14 1955
Java 多线程 测试1 Callable2 Runnable3 Thread 1 Callable package com.xu.thread; import java.util.concurrent.Callable; /** * @author Administrator */ public class MyCallable implements Callable { @Override public Object call() throws Exception {
JAVA多线程实战
超级氯化钾的博客
07-21 2770
是计算机中的程序关于某数据集合的一次运行活动，，一个线程就是进程中一个单一顺序的控制流，进程是线程的容器，一个进程至少有一个线程，一个进程可以有多个线程OS中是以进程为单位分配资源，如虚拟存储控件、文件描述符。每个线程都有自己的线程栈JVM启动时会自动创建一个主线程，该主线程负责执行main方法。主线程就是运行main方法的线程。.........
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5710
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
Java多线程（超详细）
loss_rose777的博客
08-14 2万+
25000字带你了解线程的概念，这一定是csdn上最全面的关于线程的文章，不看别后悔哦！
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 901
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 333
JDK1.0主要特性。
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1007
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 694
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值