多线程与高并发（初级）

已于 2022-04-05 19:21:35 修改
阅读量110 收藏
点赞数
分类专栏： java 文章标签： java
于 2022-03-17 19:13:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48320674/article/details/123557513
版权

进程与线程

进程：一个正在运行的程序，是系统分配资源的单位

线程：是cup调度和执行的单位

线程图片下载

package thread.file;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class jpgDownloaderThread  extends  Thread{
    private String Url;
    private String name;
    public jpgDownloaderThread(String Url,String name){
        this.Url=Url;
        this.name=name;
    }
    @Override
    public void run() {
        new JpgDownloader().download(Url,name);
        System.out.println(name+"下载完成");
    }
    //https://p.ssl.qhimg.com/dmsmty/148_148_100/t01f6b1cb843eb72a12.png
    public static void main(String[] args) {
        jpgDownloaderThread thread1 = new jpgDownloaderThread("https://p.ssl.qhimg.com/dmsmty/148_148_100/t01f6b1cb843eb72a12.png", "1.png");
        jpgDownloaderThread thread2 = new jpgDownloaderThread("https://p.ssl.qhimg.com/dmsmty/148_148_100/t01f6b1cb843eb72a12.png", "2.png");
        jpgDownloaderThread thread3 = new jpgDownloaderThread("https://p.ssl.qhimg.com/dmsmty/148_148_100/t01f6b1cb843eb72a12.png", "3.png");
        thread1.start();
        thread2.start();
        thread3.start();
        System.out.println("主程序运行完成");
    }
}

class JpgDownloader{
    public void  download(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果

 线程开启不一定立即执行，有cpu调度执行

龟兔赛跑

package thread.race;

public class Race implements Runnable {
    public static String winner;
    @Override
    public void run() {
        for (int i = 1; i <=100; i++) {
            if(Thread.currentThread().getName().equals("兔子")&&i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            boolean b = race(i);
            if (b){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }
    public boolean race(int step){
        if(winner!=null){
            return true;
        }
        if(step>=100){
            winner=Thread.currentThread().getName();
            System.out.println("胜利者是："+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }

}

常用方法 

sleep（）：睡眠

yield（）：放弃CPU资源，礼让不一定成功

join（）：相当于线程插队

package thread.method;

public class Join implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 2; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }

    public static void main(String[] args) {
        Join join = new Join();
        Thread thread = new Thread(join, "线程");
        thread.start();
        for (int i = 0; i < 2; i++) {
            if(i==1){
                try {
                    thread.join();//相当于插队，主线程阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程"+i);
        }
    }
}

  setPriority（）：设置优先级（先设置优先级再启动线程，优先级越高，证明抢cpu机会越大，但不一定最先执行）

package thread.priority;

public class Priority {
    public static void main(String[] args) {
        SetP setP = new SetP();
        Thread thread = new Thread(setP);
        Thread thread2 = new Thread(setP);
        Thread thread3 = new Thread(setP);
        Thread thread4 = new Thread(setP);
        Thread thread5 = new Thread(setP);

        thread.setPriority(1);
        thread.start();

        thread2.setPriority(7);
        thread2.start();

        thread3.setPriority(8);
        thread3.start();

        thread4.setPriority(5);
        thread4.start();

        thread5.setPriority(10);
        thread5.start();
    }

}

class  SetP implements Runnable{

    @Override
    public void run() {
        System.out.println("优先级为："+Thread.currentThread().getPriority());
    }
}

setDaemon(ture):默认为false，用户线程

线程同步

 两种方式

同步方法：直接加到发生线程安全的方法上

同步块：synchronized(发生线程安全的对象){ 发生线程安全代码块 }

package thread.safe;

public class ThreadSafe implements Runnable{
    private int i=10;
    boolean flag=true;
    @Override
    public void run() {
        while (flag){
            buy();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //synchronized  表示当前对象this  （ThreadSafe）
    /*public synchronized void buy(){
        System.out.println(Thread.currentThread().getName()+"购买了第"+i--+"张票");
        if(i<=0){
            flag=false;
        }
    }*/
    //synchronized  表示当前对象this  （ThreadSafe）
    public  void buy(){
        synchronized(this){
            System.out.println(Thread.currentThread().getName()+"购买了第"+i--+"张票");
            if(i<=0){
                flag=false;
            }
        }
    }

    public static void main(String[] args) {
        ThreadSafe threadSafe = new ThreadSafe();
        new Thread(threadSafe,"张三").start();
        new Thread(threadSafe,"李四").start();
        new Thread(threadSafe,"王五").start();
    }
}

Lock锁 

package thread.safe;

import java.util.concurrent.locks.ReentrantLock;

public class LockSafe implements Runnable {
    private int i = 10;
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if(i>0){
                    System.out.println(Thread.currentThread().getName()+"购买了第"+i--+"张票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            } finally {
                lock.unlock();
            }
        }

    }


    public static void main(String[] args) {
        LockSafe lockSafe = new LockSafe();
        new Thread(lockSafe, "张三").start();
        new Thread(lockSafe, "李四").start();
        new Thread(lockSafe, "王五").start();
    }
}

线程的五个状态 

package thread.state;

public class State {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程执行完毕");
        });

        Thread.State state = thread.getState();
        System.out.println(state);//new

        thread.start();
        state=thread.getState();
        System.out.println(state);//run

        while(state!=Thread.State.TERMINATED){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();
            System.out.println(state);
        }

    }
}

线程四种实现方法

继承Thread类 

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main方法开始执行");
        new Thread(new Thread1()).start();
        System.out.println("main方法执行结束");
    }
    public static class Thread1 extends Thread {
        @Override
        public void run() {
            System.out.println("继承thread类");
        }
    }
}

运行结果

实现Runnable接口 

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main方法开始执行");
        new Thread(new Thread1()).start();
        System.out.println("main方法执行结束");
    }
    public static class Thread1 implements Runnable {
        @Override
        public void run() {
            System.out.println("继承thread类");
        }
    }
}

运行结果

  实现Callable接口（有返回值） 

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main方法开始执行");
        FutureTask<Integer> futureTask = new FutureTask<>(new Thread1());
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
        System.out.println("main方法执行结束");
    }
    public static class Thread1 implements Callable<Integer> {
        @Override
        public Integer call() {
            System.out.println("继承thread类");
            return 1;
        }
    }
}

 运行结果（阻塞等待，等整个线程完成才获取返回值）

 线程池（避免大量创建线程造成资源浪费，影响性能） 

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(10);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //executor.execute(); 这个方法没返回值
        System.out.println("main方法开始执行");
        Future<Integer> submit = executor.submit(new Thread1());
        System.out.println(submit.get());
        System.out.println("main方法执行结束");
        executor.shutdown();

    }
    public static class Thread1 implements Callable<Integer> {
        @Override
        public Integer call() {
            System.out.println("继承thread类");
            return 1;
        }
    }
}

 运行结果

线程池的七大参数

  1. 核心线程数
  2. 最大线程数
  3. 存活时间
  4. 时间单位
  5. 阻塞队列
  6. 线程工程
  7. 拒绝策略

打工人上人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程的实现方式总结
blanceage的博客
06-06 6419
线程的实现方式共有四种，第一种是继承Thread抽象类；第二种是实现Runnable接口；第三种是实现Callable接口；最后一种是通过线程池创建线程。写一个类去继承Thread类，重写其中的run（）方法，然后调用start（）方法启动线程。写一个类去实现Runnable接口，重写其中的run（）方法；用用实现Runnable接口的对象作为参数实例化一个Thread对象，调用Thread类的start()方法来启动线程。实现Runnable接口比继承Thread类所具有的优势：1. 适合多个相同的程序代
线程的4种实现方式
m0_67656219的博客
06-05 2069
java中多线程的基础认识与状态分析
实现线程的三种方式
一个天天与人打赌周更blog被迫极限一换一的程序员骚年
02-09 750
编译–类加载–JVM调用main方法，main方法就是主线程，也就是主栈–main方法压栈–在堆中new出myThread对象–myThread对象调用start方法。–start方法的作用是在JVM中开辟一个新的栈（也就是启动一个新的线程）–新的线程启动后会自动调用run方法，而第6行的start方法执行完之后会继续往下执行。第二种：编写一个类，实现Runnable接口–>创建Runnable对象–>将Runnable对象转换为线程对象–>线程启动。优点：面向接口编程，可以继承别的类，，可扩展性强。
JUC多线程：创建线程的四种方式
张维鹏的博客
01-18 1万+
Java多线程的实现方式主要有四种： （1）继承Thread类，重写run()； （2）实现Runnable接口，重写run()； （3）实现Callable接口，实现call() 方法，通过FutureTask包装器来创建Thread线程； （4）使用ExecutorService、Callable、Future实现有返回结果的多线程。
实现线程的方法
qq_45754346的博客
05-04 678
线程的实现方法主要有三种：1.继承Thread类实现线程。2.实现Runnable接口实现线程。3.实现Callable接口实现线程。 具体介绍一下这三种线程的实现方式： 1.继承Tread类实现线程 步骤：创建一个类继承Tread类--->重写Tread类中的run（）方法---->用继承类创建一个个对象（每个对象代表一个线程）---->调用线程对象的start（）方法---->多个线程启动了 2.实现Runnable接口实现线程 步骤：创建一个类实现Runnable接口
Java多线程与并发库视频资源网盘链接
最新发布
04-11
Java多线程与并发库是Java开发者必备的重要技能之一，尤其对于处理高并发场景的应用开发至关重要。本视频资源集合旨在帮助初级开发人员深入理解和掌握这一关键领域，通过学习，你可以提升自己的程序性能优化能力，更...
初级多线程文档和视频(学习资料)
06-25
五、高并发与性能优化 1. **线程池**：为管理线程创建和销毁开销，使用线程池可以预先创建一定数量的线程，根据需求复用这些线程，提升效率。 2. **并发容器**：Java的Concurrent包提供了线程安全的集合类，如...
高并发书籍
04-24
本书旨在从初级到高级逐步讲解如何处理和优化高并发环境下的程序设计，帮助读者构建坚实的理论基础，并提供实战经验。 在高并发编程的世界里，首要任务是理解并发的基本概念，包括线程、进程、同步与异步、锁机制等...
python开发+多线程.zip
02-17
在"python开发+多线程.zip"这个压缩包中，包含了一系列关于Python编程的初级到精通的学习资料，特别是聚焦于函数、文件操作、多线程和网络编程这四个关键领域。下面将对这些主题进行深入的探讨。 首先，让我们谈谈...
线程的两种实现方式，以及区别
dreamer_8399的博客
09-04 1万+
让类成为线程类有两种方式，实现Runnable接口，以及继承Thread类（类中实现了Runnable接口，还提供了一些额外的方法）。 一、Runnable相对优势： 1、java的单继承，当继承了Thread类，则不能继承其他类，而实现Runnable接口可以 2、实现Runnable接口的线程类的多个线程，可以访问同一变量，而Thread则不能（多窗口买票问题） 原因：两种方式启动方式
Java多线程实现的四种方式
alenejinping的专栏
12-25 451
原文地址：https://blog.csdn.net/u011480603/article/details/75332435/ Java多线程实现的方式有四种     1.继承Thread类，重写run方法     2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target     3.通过Callable和FutureTas...
线程创建的四种方式
热门推荐
m0_37840000的博客
03-30 18万+
java中创建线程的四种方法以及区别 Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用四种方式来创建线程，如下所示： 1）继承Thread类创建线程 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 4）使用线程池例如用Executor框架 下面让我们分别来看看这四种创建线程的方法。 --...
线程的三种实现方法。
weixin_42107617的博客
04-08 4003
多线程创建的三种方式： 一，创建线程第一种方式（继承Thread）： * 1，自定义一个类，继承java.lang包下的Thread类 * 2，重写run方法 * 3，将要在线程中执行的代码编写在run方法中 * 4，创建上面自定义类的对象 * 5，调用start方法启动线程。 class MyThread extends Thread{ //2，重写run方法 @Overri...
1.线程实现方式
你好啊cbw
01-29 247
目录 1.线程实现方式 1.1.并行与并发 1.2.进程概念 1.3.线程概念 1.4.线程调度 1.5.主线程 1.线程实现方式 1.1.并行与并发 并发：指两个或多个事件在同一时间段内发生。(cpu交替执行任务)。 单线程时cpu先执行任务1，再执行任务2，然后再执行任务1，即并发就是指在一段时间内，cpu在两个或多个任务之间交替执行 并行：指两个或多个事件在同一时刻发生。(cpu同时执行任务，速度快)。 两个cpu执行两个任务，即并行就是多个cpu同时执行多个任务。
线程的几种实现方式？
Garry
09-13 363
一     继承thread类 1.定义Thread的子类，重写run()方法，run()方法代表了线程要完成的任务，run()方法称为线程执行体 2.创建Thread子类的实例，子类对象就是线程， 3. 调用线程对象的start()方法来启动线程     运行结果如下图所示：       二：实现runnable接口 1.定义runnable接口的实现类，重写run()方法，run()方法是线程的执行体 2,...
线程的两种实现方式及其区别
Vicali的博客
11-24 1831
线程的实现方式一：继承Thread 步骤： 1.继承Thread，创建Thread类的对象，封装一个独立的线程； 2.重写run方法，封装线程任务； 3.创建线程对象，启动线程； 继承Thread在实际开发中很少用。 线程的实现方式二：实现Runnable接口 步骤： 1.自定义实现类，实现Runnerable接口 2.重写run方法，封装线程任务 3.创建Thread类的对象，封装Runnable接口实现类，启动线程 public class ThreadDemo2 implements Runnable
创建线程的4种方式（详细解析）
NingIT的博客
08-23 3625
package com.sxt.threaddemo; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import j...
【Java基础知识】线程、进程和协程
技术能量站
08-15 869
多线程的实现方式(四种)之一 1，继承Thread类,重写run()方法 package com.wxw; /** * @author 作者 wxw * @version 创建时间：2019年8月15日 下午2:31:31 * 类说明 */ /** * 多线程的实现方式(四种)之一 * 1，继承Thread类,重写run()方法 * * 说明： * 程序启动运行m...
Java多线程与并发深度解析：原理与实践
1. **Java并发性与多线程基础** - 介绍了Java中的多线程概念，区分了并发性和并行性，强调了Java在处理多个任务时的优势，如提高资源利用率、简化程序设计以及提升程序响应速度。 2. **多线程的代价** - 虽然多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值