【个人笔记/Java】JavaSE（六）多线程

于 2022-03-25 23:58:01 发布
阅读量222 收藏
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014576547/article/details/123721190
版权

多任务

多线程

  • 程序 进程 线程

Process与Thread

程序和进程

线程的创建

Thread

  • 自定义线程类继承Thread类
  • 重写run()方法，编写线程程序执行体
  • 创建线程对象，调用start()方法启动线程
`//创建线程方式：继承Thread类，重写run()方法，调用start开启线程

public class TestThread1 extends Thread {
    @Override
    public void run() {
        //run()方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码--"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象，调用start()方法
        TestThread1 testThread1 = new TestThread1();
        testThread1.start(); //开启线程 交替执行
		testThread1.start(); //调用函数


        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

在这里插入图片描述

总结：

线程开启不一定立即执行，由CPU调度执行

在这里插入图片描述

练习：

package com.yuki.thread;

import org.apache.commons.io.FileUtils;
//import javax.naming.Name;
import java.io.File;
import java.io.IOException;
import java.net.URL;

//练习Thread，实现多线程同步下载图片
public class TestThread extends Thread{
    private String name; //图片名
    private String url; //地址
    public TestThread(String name, String url){
        this.name = name;
        this.url = url;
    }
    public void run(){
        TestThread2 testThread2 = new TestThread2();
        testThread2.downloading(url,name);
        System.out.println("下载了图片:"+name);
    }

    public static void main(String[] args) {
        TestThread t1 = new TestThread("1.jpg","https://i0.hdslb.com/bfs/album/7c4bfe98d16efd5f4d0c1f9e02d706cbfad24272.jpg@518w.jpg");
        TestThread t2 = new TestThread("2.jpg","https://i0.hdslb.com/bfs/album/5813216f98299c07dc22f16beee3600d91e27530.jpg@518w.jpg");
        TestThread t3 = new TestThread("3.jpg","https://i0.hdslb.com/bfs/album/c470e05aae7d66f1d6013f171e1c1fe96b30384f.jpg@518w.jpg");

        t1.start();
        t2.start();
        t3.start();
    }
}
class TestThread2 {

    public void downloading(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        }catch (IOException e){
            System.out.println("IO异常");
        }
    }
}

在这里插入图片描述

实现Runnable

  • 定义MyRunnable类实现Runnable接口
  • 实现run()方法，编写线程体
  • 创建线程对象，调用start()方法启动线程
//创建线程方法，实现runable接口，重写run方法，执行线程需要丢入runable接口实现类，调用start方法
public class Demo02 implements Runnable{
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("多线程");
        }
    }

    public static void main(String[] args) {
        //创建runable接口的实现类对象
        Demo02 demo02 = new Demo02();
        //创建线程对象，通过线程对象来开启线程，代理
        new Thread(demo02).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("代码！");
        }
    }
}

小结：

  • 继承Thread类
    • 子类继承Thread类具备多线程能力
    • 启动线程：子类对象.start()
    • 不建议使用：避免OPP单继承局限性
  • 实现Runnable接口
    • 实现接口Runnable具有多线程能力
    • 启动线程：传入目标对象+Thread对象.start()
    • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
//多线程操作同一个对象
//买火车票问题
//问题：多个线程操作同一个对象的情况下，线程不安全，数据混乱
public class TestThread04 implements Runnable{

    //票的数量
    private int tickNums = 10;

    public void run(){
        while(true){
            if (tickNums<=0){
                break;
            }
            try{
                Thread.sleep(200);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢到了第"+tickNums--+"张票");
        }
    }

    public static void main(String[] args) {
        TestThread04 testThread04 = new TestThread04();

        new Thread(testThread04,"小明").start();
        new Thread(testThread04,"老师").start();
        new Thread(testThread04,"黄牛").start();
    }
}

在这里插入图片描述

案例：龟兔赛跑

public class Race implements Runnable{

    //胜利者
    private static String winner;

    public void run(){
        if(Thread.currentThread().getName().equals("兔子")){
            for (int i = 0; i <= 100; i+=3) {
                //模拟兔子休息
                if(i%10==0){
                    try{
                        Thread.sleep(1);
                    }catch (InterruptedException E){
                        E.printStackTrace();
                    }
                }
                boolean flag = getOver(i);
                if(flag){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
            }
        }
        if(Thread.currentThread().getName().equals("乌龟")){
            for (int j = 0; j <= 100; j++) {
                boolean flag = getOver(j);
                if(flag){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"-->跑了"+j+"步");
            }
        }
    }

    //判断比赛是否结束
    public boolean getOver(int steps){
        //判断是否有胜利者
        if(winner!=null){
            return true;
        }
        if(steps>=100){
            winner = Thread.currentThread().getName();
            System.out.println("胜利者是"+winner);
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();

        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

在这里插入图片描述

实现Callable接口（了解）

  • 实现Callable接口，需要返回值类型
  • 重写call方法，需要抛出异常
  • 创建目标对象
  • 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(3);
  • 提交执行：Future result = ser.submit(t1);
  • 获取结果：boolean r1 = result.get();
  • 关闭服务：ser.shutdown()
//线程创建方式三：使用Callable接口
/*
优点：
1.可以定义返回值
2。可以抛出异常
 */
public class TestCallable implements Callable<Boolean> {
    private String name; //图片名
    private String url; //地址
    public TestCallable(String name, String url){
        this.name = name;
        this.url = url;
    }
    public Boolean call(){
        Download  download = new Download();
        download.downloading(url,name);
        System.out.println("下载了图片:"+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("1.jpg","https://i0.hdslb.com/bfs/album/7c4bfe98d16efd5f4d0c1f9e02d706cbfad24272.jpg@518w.jpg");
        TestCallable t2 = new TestCallable("2.jpg","https://i0.hdslb.com/bfs/album/5813216f98299c07dc22f16beee3600d91e27530.jpg@518w.jpg");
        TestCallable t3 = new TestCallable("3.jpg","https://i0.hdslb.com/bfs/album/c470e05aae7d66f1d6013f171e1c1fe96b30384f.jpg@518w.jpg");
        //创建执行服务：
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务
        ser.shutdown();
    }
}

class Download {

    public void downloading(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        }catch (IOException e){
            System.out.println("IO异常");
        }
    }
}

在这里插入图片描述

静态代理模式

  • 真实对象和代理对象都要实现同一接口
  • 代理对象要代理真实角色
//静态代理模式总结：
//真实对象和代理对象都要实现同一接口
//代理对象要代理真实角色
//好处：
    //代理对象可以做很多真实对象做不了的事情
    //真实对象专注做自己的事情
public class Demo01 {
    public static void main(String[] args) {
        You you = new You(); //你要结婚
        WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

class You implements Marry{
    public void HappyMarry(){
        System.out.println("结婚！");
    }
}

class WeddingCompany implements Marry{
    private Marry target;
    public WeddingCompany(Marry target){
        this.target = target;
    }
    public void HappyMarry(){
        this.before();
        this.target.HappyMarry(); //真实对象
        this.after();
    }

    private void after(){
        System.out.println("结婚之后，收尾款！");
    }
    private void before(){
        System.out.println("结婚前，布置");
    }

}

线程的五大状态

在这里插入图片描述

停止线程

  • 不推荐使用JDK提供的stop()、destory()方法。已废弃
  • 推荐自己让线程停下来
  • 建议使用一个标志位进行终止变量当flag=false，则终止线程运行
//测试stop
//1.建议线程正常停止-->利用次数，不建议死循环
//2.建议使用标志位-->设置一个标志位
//3.不要使用stop或者destory等过时或者JDK不建议使用的方法
public class TestStop implements  Runnable{

    //1.设置一个标志位
    private boolean flag = true;

    public void run(){
        int i = 0;
        while (flag){
            System.out.println("run....Thread"+i++);
        }
    }
    //2.设置一个公开的方法，转换标识位停止线程
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if(i==900){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程停止");
            }
        }
    }
}

线程休眠

  • sleep（时间）指定当前线程阻塞的毫秒数
  • sleep存在异常InterruptedException
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延时，倒计时等
  • 每个对象都有一个锁，sleep不会释放锁

模拟网络延时：放大问题的发生性

模拟倒计时

//模拟倒计时
public class TestSleep02 {
    public static void main(String[] args) {
        //打印当前系统时间
        Date startTime = new Date(System.currentTimeMillis()); //获取系统当前时间

        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis()); //更新当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println();
        }
    }
    //模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 10;

        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

线程礼让

  • 线程礼让就是让当前执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度，礼让不一定成功！看cpu心情

Join

  • Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
  • 可以想象成插队
//测试Join方法 插队
public class TestJoin implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();

        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 500; i++) {
            if (i==200){
                thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

线程状态观测

Thread.State

线程状态

  • NEW：未启动的线程处于此状态
  • RUNABLE：在Java虚拟机中执行的线程处于此状态
  • BLOCKED：被阻塞等待监视器锁定的线程处于此主题
  • WAITING：正在等待一个线程执行特定动作的线程处于此状态
  • TIME WAITING：正在等待另一个线程执行动作达到指定时间的线程处于此状态
  • TERMINATED：已退出的线程处于此状态
//观察测试线程的状态
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } 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){ //只要线程不终止，就一直输出
            Thread.sleep(1000);
            state = thread.getState(); //更新线程状态
            System.out.println(state); //输出状态
        }
        
    }
}

在这里插入图片描述

线程优先级

Java提供了一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调用哪个线程

优先级用数字表示，1~10

  • Thread.MIN_PRIORIYT = 1;
  • Thread.MAX_PRIORITY = 10;
  • Thread.NORM_PRIORITY = 5;

使用以下方式改变优先级：

  • getPriority().setPriority(int xxx)

优先级低只意味着获得调度的概率低，并不是优先级低就不会被调用了。

//测试线程优先级
public class TestPriority {
    public static void main(String[] args) {
        //主线程优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //设置优先级再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY); //MAX_PRIORITY=10
        t4.start();

        t5.setPriority(8);
        t5.start();

        t6.setPriority(7);
        t6.start();
    }
}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如：后台记录操作日志，监控内存，垃圾回收等
//测试守护线程
public class TestDemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true); //默认false表示用户线程，正常线程都是用户线程

        thread.start(); //上帝线程启动

        new Thread(you).start(); //你 用户线程启动
    }
}

//上帝
class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你");
        }
    }
}

//你
class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心的活着");
        }
        System.out.println("====goodbey!world====");
    }
}

线程同步

多个线程操纵同一个资源

并发：同一个对象被多个线程同时操作

队列和锁

锁机制synchronired

三大不安全案例

不安全的买票

//不安全的买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"苦逼的我").start();
        new Thread(station,"牛逼的你们").start();
        new Thread(station,"可恶的黄牛党").start();

    }
}

class BuyTicket implements Runnable{

    //票
    private int ticketNum = 10;
    boolean flag = true; //外部停止方式
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNum<=0){
            flag = false;
            return;
        }
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
    }
}

不安全的取钱

//不安全的取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"结婚基金");

        Drawing you = new Drawing(account, 50, "你");
        Drawing girlfriend = new Drawing(account, 100, "girlfriend");

        you.start();
        girlfriend.start();
    }
}

//账户
class Account {
    int money;
    String name;

    public Account(int money, String name){
        this.money = money;
        this.name = name;
    }
}

//银行；模拟取款
class Drawing extends Thread{
    Account account; //账户
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int newMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    public void run(){
        //判断有没有钱
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够了，取不了");
            return;
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额 = 余额 - 你取的钱
        account.money = account.money - drawingMoney;
        //你手里的钱
        newMoney = newMoney + drawingMoney;
        System.out.println(account.name+"余额为:"+account.money);
        //this.getName()+Thread.currentThread().getName()
        System.out.println(this.getName()+"手里的钱:"+newMoney);
    }
}

线程不安全的集合

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

同步方法

加上synchronized关键字变成同步方法

同步块

  • 同步块：synchronized(Obj）{}
  • Obj称之为同步监视器
    • Obj可以是任何对象，但推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，同步的就是this（本身）
  • 同步监视执行过程：

（待续未完！）

番外 如何在vscode导入jar包

在练习多线程创建和运行的时候，需要commons.io的类，这个是jdk默认没有的，需要我们自己导入jar包，首先进入官网，找到我们需要的文件点击下载，

在这里插入图片描述
将下载的文件解压出来，在我们的Java项目文件夹下面新建一个lib文件夹

在这里插入图片描述
摁下Shift+Ctrl+P打开命令行窗口，输入Java: Clean the Java language server workspace，点击，在运行程序

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
运行成功！

Yuki i i i i i i i
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程编程总结(java 1.6版)
02-12
1.8版还有更多新特性 原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://lavasoft.blog.51cto.com/62575/27069
狂神说Java笔记资料
04-14
狂神说Java笔记PDF文档。内容包括JAVA入门、基础语法、流程控制、方法、数组、面向对象、异常机制、常用类、集合框架、IO流、多线程、网络编程、Gui编程、注解和反射。
java多线程
qq_40320556的博客
08-29 253
第一章：并发编程的挑战 一、上下文切换 巧妙地利用了时间片轮转的方式, CPU 给每个任务都服务一定的时间，然后把当前任务的状态保存下来，在加载下一任务的状态后，继续服务下一任务，任务的状态保存及再加载, 这段过程就叫做上下文切换。时间片轮转的方式使多个任务在同一颗 CPU 上执行变成了可能。 进程 (有时...
javaSE（6）多线程
weixin_43230682的博客
07-19 195
目录 ## 6.多线程 ### 6.1 多线程概念 ### 6.2 创建线程的方式 ### 6.3 线程常用的方法 ### 6.4 线程安全 ### 6.5 线程同步 ### 6.6 线程池 ## 6.多线程 ### 6.1 多线程概念 **进程是什么(process)** 对一个程序的运行状态, 以及在运行中所占用的资源(内存, CPU)的描述; 一个进程可以理解为一个程序; 但是反之, 一个程序就是一个进程, 这句话是错的。 进程的特点: - 独立性: 不同的进程之间是相互独
Java1.6多线程之同步方法
wenin819的CSDN空间
12-23 935
package com.starit.open.main; import java.util.ArrayList; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Exec
java1.6 线程池_Java多线程编程-使用JDK1.6的线程池
weixin_34646919的博客
03-07 346
Java对多线程的支持还是比较给力的，JDK1.6里面有现成的API可用，一般的多线程应用足够了，使用的时候注意最好加一层壳子，至少方便日志打印和后续扩展，以下是一个简单的启用的例子1. 定义线程池变量//线程池维护线程的最少数量: 2;//线程池维护线程的最大数量: 100;//线程池维护线程所允许的空闲时间: 2s;//线程池维护线程所允许的空闲时间的单位: TimeUnit.SECONDS;...
JavaSE精华笔记.zip
01-06
Java基础部分笔记，包含IO流、多线程、网络编程、Lambda表达式，适合巩固基础以及新手查看，都是Java基础的精华
JavaSE笔记11111
最新发布
10-15
JavaSE笔记涵盖 面向对象的三大特征:继承,多态,封装 单列集合与双列集合:collection & map IO流:InputStream字节输入流,OutputStream字节输出流,Reader字符输入流,Writer字符输出流; 多线程&线程池; 反射&动态代理等
javaSE经典笔记( 完整）
05-19
javaSE笔记、经典、全面 基本操作 Java基础 面向对象 多线程 String类 集合 IO GUI socket网络编程 正则表达式
狂神说上课笔记未删减 Java基础到技术升级
08-09
11、JavaSE：多线程 12、JavaSE：网络编程 13、JavaSE：Gui编程 14、JavaSE：注解和反射 15、MySQL和JDBC 16、前端：Html5 17、前端：CSS3 18、前端：JavaScript、jQuery 19、JavaWeb 20、MyBatis 21、...
Java实现多线程下载JAR包
07-03
用NetBeans编的一个Java多线程下载程序，这只是一个JAR包，大家可以感受下哈！
java-多线程下载器（支持断点续传、线程加减）包含源码和可运行jar包 第二版
04-17
注意： 如果下载后无法直接运行，则查看电脑是否有F盘，如果没有，可修改jar包中的配置文件，将默认路径设置到其他盘，如C盘 说明： 1、这是myDownloader2.0自制下载器，在1.0版本的基础上做了修正和功能上的扩展； 2、该“myDownloader2.0资源包”包括： （1）“myDownloader_2.0”文件夹，保存下载器的源码， 其中包含的doc文件夹存放的是有MyEclipse，javadoc生成的关于下载器的API文档； （2）“jar包”文件夹，其中myDownloader2.0.jar可以双击运行下载器 （前提，电脑上装有JDK环境）。 3、可查看下载器“功能介绍”了解下载器具体功能。 功能介绍; 1、基本下载功能； 2、支持多任务多线程同时下载； 3、每个任务的线程数由用户在新建任务时自定义，缺省为5个线程； 4、任务下载过程中可以点击“线程+”或“线程-”即时增减线程； 5、选择任务，可以在任务信息栏中查看任务下载的信息； 6、对于正在下载和暂停的任务，可以再下载分块图示中查看文件的分块下载情况； （灰色为未下载，绿色为下载中，蓝色为完成） 7、若下载中删除任务，则任
【Java】6、Java 多线程
Tellsea
01-13 420
文章目录多线程进程和线程概念进程概念线程概念进程和线程的区别线程的状态转换新建状态(New)就绪状态(Runnable)运行状态(Running)阻塞状态(Blocked)死亡状态(Terminated)线程状态转换图线程的调度多线程同步多线程的 6 种实现方式一、继承 Thread 类二、实现 Runnable 接口三、使用内部类的方式四、定时器五：带返回值的线程六：基于线程池的方式Spring 方式：使用 Spring 来实现多线程首先定义配置类定义要执行的任务测试类输出结果微信公众号 多线程 进程和线
java 线程包_JAVA打jar包和线程
weixin_39630735的博客
02-16 235
jar包打包有很多中其中有用命令 jar cvf 指定java文件 名称 和Linux tar打包是一样的jar包打包成功后，点击MANIFEST文件 加入参数 Main-Class: 指定初始启动类THread是个生成线程的类，他包含有对象name；实现THread，必须包含run方法有俩个方式实现线程：方式一 ：1. 自定义一个类继承Thread类。2. 重写Thread类的r...
深入理解Java之线程池 JDK1.6版
wuyangyang555的博客
06-25 954
出处：http://www.cnblogs.com/dolphin0520/　　　　本文归作者海子和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。　　     在前面的文章中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：　　如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，...
【Java基础】并发 - 多线程
王晓斌的专栏
05-03 1605
介绍 Java多线程 多线程任务执行 大多数并发应用程序时围绕执行任务（task）进行管理的；所谓任务就是抽象的，离散的工作单元。 围绕执行任务来管理应用程序时，第一步是要指明一个清晰的任务边界。大多数应用服务器程序都选择了下面这个自然的任务辩解：单独的客户请求； 任务时逻辑上的单元； 任务 Runnable 表示一个任务单元（java.lang） public inte
Java基础---“接口”实现时的另一种方式。通过Java JDK API 1.6.0文档实例发现并得出结论
Nick_kj的专栏
04-05 751
在自学到“多线程通信时”发现Java JDK API 1.6中的java.util.concurrent.locks；API给的实例中有三行代码如下： final Lock lock = new ReentrantLock(); final Condition notFull = lock.newCondition(); final Condition notEmpt
从头认识多线程-1.6 迫使线程停止的方法-异常法
raylee2007的专栏
04-15 1844
这一章节我们来讨论一下迫使线程停止的方法-异常法。1.伪停止法在介绍异常法前，我们来看一下一个伪停止的例子。一般使用多线程，都是在执行一些循环任务，那么，我只要停止了for，就停止了线程了，这是错误的。例子package com.ray.deepintothread.ch01.topic_6; public class FakeInterruptSample { public static v
https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html
03-16
这是Oracle官网上Java SE 8的下载页面，其中提供了Java SE 8开发工具包（JDK）和Java SE 8运行时环境（JRE）的下载链接。用户可以根据自己的需要选择不同的平台和版本进行下载安装。注意，Java SE 8已经不再接收免费...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值