java 多线程学习2 2021/09/04

最新推荐文章于 2023-09-14 23:51:21 发布
最新推荐文章于 2023-09-14 23:51:21 发布
阅读量63 收藏
点赞数 1
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xpc1998/article/details/120106033
版权

java 多线程学习2 2021/09/04

线程停止、线程休眠、线程礼让、线程强制执行

  • 线程停止最好用自己写的stop()方法

观察线程状态

  • 线程有五个状态： NEW/RUNNABLE/TIME_WAITING/TERMINATED
  • 用Thread.State可以观察到
public class TestThreadState {
    public static void main(String[] args) {
        Thread th = new Thread(new MyThread());
        Thread.State state=th.getState();    //Thread.State 是Thread里面的一个枚举
        System.out.println(state);
        th.start();
        while(state!=Thread.State.TERMINATED){ //TERMINATED是Thread.State里面的一个枚举变量
            try {
                th.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = th.getState();  //此处要有状态更新才能获取到TERNINATED
        }
        System.out.println(state);
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 2; i++) {
            System.out.println(Thread.currentThread().getState());
        }
    }
}

线程优先级

  • 优先级高，只是被执行的概率高，优先级高->低 对应是 10–>1
public class TestThreadState {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"-->"+
                Thread.currentThread().getPriority()+"执行");
        MyThread t=new MyThread();
        Thread th1=new Thread(t,"线程1");
        Thread th2=new Thread(t,"线程2");
        Thread th3=new Thread(t,"线程3");
        th1.setPriority(1);
        th2.setPriority(2);
        th3.setPriority(3);
        th1.start();
        th2.start();
        th3.start();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+
                Thread.currentThread().getPriority()+"执行");
    }
}
//输出是：
main-->5执行
线程3-->3执行
线程1-->1执行
线程2-->2执行

线程分为用户线程和守护线程

  • 主线程是用户线程，必须执行完
  • 垃圾回收。。是守护线程，可以不执行完

线程同步【重点】

//线程不安全的例子：银行取钱
public class Application {
    public static void main(String[] args) {
        Person p1 = new Person("丈夫", 80);
        Person p2 = new Person("妻子", 50);
        Drawing drawing1=new Drawing(p1);
        Drawing drawing2=new Drawing(p2);
        new Thread(drawing1).start();
        new Thread(drawing2).start();
    }
}
class Person{
    private String name;
    private int drawMoney;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getDrawMoney() {
        return drawMoney;
    }

    public void setDrawMoney(int drawMoney) {
        this.drawMoney = drawMoney;
    }

    public Person(String name, int drawMoney) {
        this.name = name;
        this.drawMoney = drawMoney;
    }
}
class Drawing implements Runnable{
    public static int money=100;
    Person person;
    public Drawing(Person person) {
        this.person = person;
    }
    @Override
    public void run() {
        drow(person);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void drow(Person person) {
        if (money - person.getDrawMoney() >= 0) {
            money-=person.getDrawMoney();
            System.out.println(person.getName()+"取了"+person.getDrawMoney()+"   余额："+money);
        }
    }
}
//输出结果  存在线程同步问题
丈夫取了80   余额：-30
妻子取了50   余额：-30

//线程不安全的集合：比如List就是不安全的，1000个线程同时往里面添加元素会出问题，因为List里面没解决线程同步问题
public class MyThread {
    public static void main(String[] args) {
        Th th=new Th();
        for (int i = 0; i < 1000; i++) {
            new Thread(th).start();
        }
        System.out.println(th.list.size());
    }
}
class Th implements Runnable{
    ArrayList<Integer> list=new ArrayList<>(1000);
    @Override
    public void run() {
        list.add(1);
    }
}
//输出结果【应该是1000】 注意：此处用锁好像没用
433

//用Synchronized方法和Synchronized块来解决银行取钱不安全的问题
public class Application {
    public static void main(String[] args) {
        Person p1 = new Person("丈夫", 80);
        Person p2 = new Person("妻子", 50);
        Drawing drawing1=new Drawing(p1);
        Drawing drawing2=new Drawing(p2);
        new Thread(drawing1).start();
        new Thread(drawing2).start();
    }
}
class Person{
    private String name;
    private int drawMoney;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getDrawMoney() {
        return drawMoney;
    }

    public void setDrawMoney(int drawMoney) {
        this.drawMoney = drawMoney;
    }

    public Person(String name, int drawMoney) {
        this.name = name;
        this.drawMoney = drawMoney;
    }
}
class Drawing implements Runnable{
    public static int money=100;
    Person person;
    public Drawing(Person person) {
        this.person = person;
    }
    @Override
    public void run() {
        synchronized ((Integer)money){  //此处是synchronized块处理
            drow(person);
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void drow(Person person) {   //此处是synchronized方法处理
        if (money - person.getDrawMoney() >= 0) {
            money-=person.getDrawMoney();
            System.out.println(person.getName()+"取了"+person.getDrawMoney()+"   余额："+money);
        }
    }
}
//输出结果
丈夫取了80   余额：20
----------------------------------------------------------
//正规写法
public class Account {
    private int Money;

    public Account(int money) {
        Money = money;
    }

    public int getMoney() {
        return Money;
    }

    public void setMoney(int money) {
        Money = money;
    }
}
public class Person {
    private String name;
    private int drawMoney;

    public Person(String name, int drawMoney) {
        this.name = name;
        this.drawMoney = drawMoney;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getDrawMoney() {
        return drawMoney;
    }

    public void setDrawMoney(int drawMoney) {
        this.drawMoney = drawMoney;
    }
}
public class Bank implements Runnable{
    private static Account account;
    private static Person person;

    public Bank(Account account, Person person) {
        this.account = account;
        this.person = person;
    }
    @Override
    public void run() {
        synchronized (account) {  //此处用了synchronized
            this.draw();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public void draw() {
        if (account.getMoney() - person.getDrawMoney() < 0) {
            System.out.println("钱不够了，取不了");
        } else {
            System.out.println(person.getName()+"取了"+person.getDrawMoney()+"万元"+
            "   余额："+(account.getMoney()-person.getDrawMoney()));
            account.setMoney(account.getMoney()-person.getDrawMoney());
        }
    }
}
public class Application {
    public static void main(String[] args) {
        Account account=new Account(100);
        Person p1 = new Person("老公", 80);
        Person p2 = new Person("妻子", 50);
        Bank bank1=new Bank(account,p1);
        Bank bank2=new Bank(account,p2);
        new Thread(bank1).start();
        new Thread(bank2).start();
    }
}
//输出【线程安全的】
妻子取了50万元   余额：50
妻子取了50万元   余额：0

//Lock()锁例子：实现线程安全的抢票程序
//用ReentrantLock创建 lock对象实现加锁
public class application {
    public static void main(String[] args) {
        BuyTicket th1 = new BuyTicket();
        new Thread(th1,"线程1").start();
        new Thread(th1,"线程2").start();
        new Thread(th1,"线程3").start();
    }
}

class BuyTicket implements Runnable {
    private final ReentrantLock lock = new ReentrantLock();//声明锁
    public static int ticketNum=10;
    @Override
    public void run() {
        while(true) {
            try {
                lock.lock();   //加锁
                if (ticketNum > 0) {
                    System.out.println(Thread.currentThread().getName()+"拿了第"
                            +ticketNum--+"张票");
                }else{
                    break;
                }
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock(); //如果有try catch则放到finnaly里面解锁
            }
        }
    }
}

线程协作【线程通信】

//生产者消费者问题

线程池

//用ExcuteService service=Excutors.newFixedpools(int)来创建
不进大厂不改名--
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 线程池的原理与实现
wuce7758的专栏
12-10 544
简单介绍    创建线程有两种方式：继承Thread或实现Runnable。Thread实现了Runnable接口，提供了一个空的run()方法，所以不论是继承Thread还是实现Runnable，都要有自己的run()方法。    一个线程创建后就存在，调用start()方法就开始运行（执行run()方法），调用wait进入等待或调用sleep进入休眠期，顺利运行完毕或休眠被中断或运行过程中出现
java 调用其他线程_java 后台接口另起一个线程执行其他业务
weixin_39986060的博客
02-13 1058
直接post代码，然后在详细介绍为什么：packagecom.xxx.testset.service.impl;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/**** @function xxx接口实现类*@authorLiangjw* @date 2019-9-18 下午02:...
Java/ExecutorService中多线程服务ExecuteService的使用
最新发布
★【World Of Moshow 郑锴】★
09-14 2743
ExecutorService 是 Java 中的一个接口，它扩展了 Executor 接口，并提供了更多的方法来处理多线程任务。它是 Java 中用于执行多线程任务的框架之一，可以创建一个线程池，将多个任务提交到线程池中执行。ExecutorService 接口提供了许多方法，如 shutdown()、shutdownNow()、submit()、execute()、invokeAll() 等，可以更方便地提交任务、执行任务、关闭线程池等操作。
ExecutorService 的理解与使用
互联网那些事
11-20 1092
接口 java.util.concurrent.ExecutorService 表述了异步执行的机制，并且可以让任务在后台执行。壹個 ExecutorService 实例因此特别像壹個线程池。事实上，在 java.util.concurrent 包中的 ExecutorService 的实现就是壹個线程池的实现。 ExecutorService 样例 这里有壹個简单的使用Java 实现...
细讲Java线程池Executor
Java_ttcd的博客
08-06 776
CPU密集型 ：线程池的大小推荐为CPU数量 + 1，CPU数量可以根据Runtime.availableProcessors方法获取CPU数量 * CPU利用率 * (1 + 线程等待时间/线程CPU时间)将任务分为CPU密集型和IO密集型，然后分别使用不同的线程池去处理，从而使每个线程池可以根据各自的工作负载来调整推荐使用有界队列，有界队列有助于避免资源耗尽的情况发生。...
Java多线程 基础学习笔记 / 学习静态代理模式-附件资源
03-05
Java多线程 基础学习笔记 / 学习静态代理模式-附件资源
Java学习源码Java多线程的代码
06-15
在char01包里放置Java多线程基本知识的代码。内容如下： 如何使用多线程 如何得到多线程的一些信息 如何停止线程 如何暂停线程 线程的一些其他用法 在char02包里放置了Java对变量和对象并发访问的知识的代码...
Java多线程并发执行demo代码实例
08-18
今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在上面的代码中，我们可以看到泛型的使用，例如`public abstract class MultiThread, T>`。泛型是Java 5中引入的一种机制，它可以...
java多线程tcpsocketserver源码-Java-Book:Java学习资料整理
06-05
java多线程tcp socket server源码 Java学习资料整理 框架 / dubbo监控 / / / / / / / / / / / / / / / / / / / / 收藏 / 技术社区 书籍推荐 计算机基础 计算机科学导论 --(如果不是计算机科班的，应先看看计算机基础...
Java并发编程 —— 线程池
MercuryG的博客
06-15 1363
线程的缺点： 1、线程的创建需要开辟内存资源：本地方法栈、虚拟机栈、程序计数器等线程私有变量的内存。所以频繁的创建和消耗会带来一定的性能开销 2、使用线程不能友好的管理任务和友好的拒绝任务。在《阿里巴巴java开发手册》中要求，线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。 线程池：   定义：使用池化技术来管理和使用线程的技术，就叫做线程池 线程池的创建方式包含7种 创建方式一：创建固定个数的线程池 package ThreadPool; import java.util.concu
java executorservice的使用_java ExecutorService使用方法详解
weixin_30499067的博客
02-24 705
下面的例子主要讨论两个问题：问题1.线程池固定大小，假设为5.那么向线程池放入10个线程，运行效果如何？其他线程的状态？问题2.那么如何从线程池中移除某一个线程，确切说是使某一个线程成为空闲线程？例子：package com.dada.executorService;import java.util.concurrent.TimeUnit;public class JobThread extend...
ExecutorService的execute和submit方法
sprita1的专栏
04-03 6523
因为之前一直是用的execute方法，最近有个情况需要用到submit方法，所以研究了下。 三个区别： 1、接收的参数不一样 2、submit有返回值，而execute没有 Method submit extends base method Executor.execute by creating and returning a Future that can
线程池中Executor、ExecuteService、Executors 的区别
阳光温热，岁月静好，你还不来，我怎敢老去……
04-21 5987
Executor、ExecuteService都是接口，ExecuteService继承了Executor， Executor：接口 接口Executor里面只有一个execute方法：  void execute(Runnable command) ExecutorService：接口 接口ExecutorService继承了Executor public interface
java线程池服务ExecutorService
本作者：想花
12-16 274
5. ExecutorService ExecutorService的submit和execute ExecuteService代表的是Executors创建的线程池 submit提交的是Callable方法，返回Future，说明submit是有返回值的 execute执行的是Runnable方法，没有返回值 所以submit和execute的区别是提交的方法和是否有返回值 ExecutorService的shutdown，shutdownNow，awaitTermination shutdown方法：平
Java线程池 ExecutorService
weixin_33918114的博客
10-27 1442
本篇主要涉及到的是java.util.concurrent包中的ExecutorService。ExecutorService就是Java中对线程池的实现。 一、ExecutorService介绍 ExecutorService是Java中对线程池定义的一个接口，它java.util.concurrent包中，在这个接口中定义...
java——》ExecutorService
小仙~
04-02 785
版权声明：本文为博主原创文章，无需授权即可转载，甚至无需保留以上版权声明，转载时请务必注明作者。 https://blog.csdn.net/weixin_43453386/article/details/88661622 java——》ExecutorService一、线程池相关概念1、为什么需要创建线程池2、线程池的好处 一、线程池相关概念 1、为什么需要创建线程池 （1）服务器如果每一个请...
java中ExecutorService接口
孤云博客
04-02 2850
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666) 一、声明 public interface ExecutorService extends Executor 位于java.util.concurrent包下 所有超级接口：Executor 所有已知...
ExecutorService线程池
ljl_xyf的专栏
12-20 345
ExecutorService 建立多线程的步骤： 1。定义线程类 class Handler implements Runnable{ } 2。建立ExecutorService线程池 ExecutorService executorService = Executors.newCachedThreadPool(); 或者 int cpuNums = Runt...
"深入学习JAVA多线程编程技巧
本文将深入介绍JAVA语言中的多线程编程。多线程是指在一个Java程序中创建若干分离的线程，控制线程使用的代码...希望读者能够通过本文的学习，更好地掌握多线程编程的技巧，为自己的Java编程能力加上一道亮丽的风景线。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值