java多线程

最新推荐文章于 2022-10-08 17:26:41 发布
最新推荐文章于 2022-10-08 17:26:41 发布
阅读量117 收藏
点赞数
分类专栏： java修炼之路——java基础

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class ThreadSx {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        for (int i = 0; i < 10; i++) {
            Thread01 thread01 = new Thread01();
            thread01.start();
        }
        Thread02 thread02 = new Thread02();
        for (int i = 0; i < 10; i++) {
          new Thread(thread02).start();
        }
        for (int i = 0; i < 10; i++) {
            FutureTask<String> ft = new FutureTask<>(new Thread03());
            new Thread(ft).start();
            System.out.println(ft.get());
        }
    }
}


class Thread01 extends Thread{
    public void run() {
        System.out.println("thread实现=>"+Thread.currentThread().getName());
    }

}

class Thread02 implements Runnable{

    @Override
    public void run() {
        System.out.println("runnable实现=>"+Thread.currentThread().getName());
    }
}

class Thread03 implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "callable实现=>"+Thread.currentThread().getName();
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
yeield:在这里插入图片描述

public class YieldTest {
    public static void main(String[] args) {
        ThreadYield threadYield = new ThreadYield();
        new Thread(threadYield,"a").start();
        new Thread(threadYield,"b").start();
    }
}
class ThreadYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"===>开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"===>执行结束");
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class DeamonTest {
    public static void main(String[] args) {
        God god = new God();
        People people = new People();

        new Thread(people,"people").start();

        Thread godThread = new Thread(god,"god");
        godThread.setDaemon(true);
        godThread.start();

    }
}
class God implements Runnable{

    @Override
    public void run() {
        while(true){
            System.out.println(Thread.currentThread().getName()+"==>守护着你");
        }

    }
}

class People implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 30000; i++) {
            System.out.println(Thread.currentThread().getName()+"==>活着第"+i+"天");
        }
    }
}

在这里插入图片描述
在这里插入图片描述

package com.thread.demo01;

public class UnScychronizedTest01 {
    public static void main(String[] args) {
        BuyTicker buyTicker= new BuyTicker();
            new Thread(buyTicker,"小明").start();
            new Thread(buyTicker,"大明").start();
            new Thread(buyTicker,"黄牛党").start();
    }
}

class BuyTicker implements Runnable{

    private int tickerName=10;

    private boolean flag = true;
    @Override
    public void run() {
        while(flag){
            buy();
        }

    }

    private void buy(){
        if(tickerName<=0){
            flag = false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"===>拿到了"+tickerName--);
    }
}

package com.thread.demo01;

public class UnScychronizedTest02 {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,20,"你");
        Drawing  grilFriend = new Drawing(account,100,"grilFriend");
        you.start();
        grilFriend.start();
    }
}
class Account{
    int money;
    String name;

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

    public void setMoney(int money) {
        this.money = money;
    }

    public String getName() {
        return name;
    }

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

class Drawing extends Thread{
    Account account;
    int drawMoney;
    int nowMoney;
    public Drawing( Account account,int drawMoney,String name){
        super(name);
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    public void run() {
        if (account.money - drawMoney < 0 ){
            System.out.println(Thread.currentThread().getName()+"钱不够了，取不了");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money = account.getMoney()-drawMoney;
        nowMoney = nowMoney+drawMoney;
        System.out.println(account.getName()+"余额为："+account.getMoney());
        System.out.println(this.getName()+"手里的钱："+nowMoney);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.thread.demo01;

public class UnScychronizedTest01 {
    public static void main(String[] args) {
        BuyTicker buyTicker= new BuyTicker();
            new Thread(buyTicker,"小明").start();
            new Thread(buyTicker,"大明").start();
            new Thread(buyTicker,"黄牛党").start();
    }
}

class BuyTicker implements Runnable{

    private int tickerName=10;

    private boolean flag = true;
    @Override
    public void run() {
        while(flag){
            buy();
        }

    }

    private synchronized void buy(){
        if(tickerName<=0){
            flag = false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"===>拿到了"+tickerName--);
    }
}

在这里插入图片描述
在这里插入图片描述

package com.thread.demo01;

public class UnScychronizedTest02 {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,20,"你");
        Drawing  grilFriend = new Drawing(account,100,"grilFriend");
        you.start();
        grilFriend.start();
    }
}
class Account{
    int money;
    String name;

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

    public void setMoney(int money) {
        this.money = money;
    }

    public String getName() {
        return name;
    }

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

class Drawing extends Thread{
    Account account;
    int drawMoney;
    int nowMoney;
    public Drawing( Account account,int drawMoney,String name){
        super(name);
        this.account = account;
        this.drawMoney = drawMoney;
    }

    @Override
    public  void run() {
        synchronized (account){
            if (account.money - drawMoney < 0 ){
                System.out.println(Thread.currentThread().getName()+"钱不够了，取不了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money = account.getMoney()-drawMoney;
            nowMoney = nowMoney+drawMoney;
            System.out.println(account.getName()+"余额为："+account.getMoney());
            System.out.println(this.getName()+"手里的钱："+nowMoney);
        }
        }
}

在这里插入图片描述

package com.thread.demo01;

public class DeadLockTest {
    public static void main(String[] args) {
        MakeUp g1 = new MakeUp(0,"灰姑凉");
        MakeUp g2 = new MakeUp(1,"白雪公主");
        g1.start();
        g2.start();
    }
}
//口红
class Lipstick{

}

//镜子
class Mirror{

}

class MakeUp extends Thread{
    static Lipstick lipstick = new Lipstick();
    static  Mirror mirror = new Mirror();

    int choice;//选择
    String grilName;//使用化妆品的人
    MakeUp(int choice,String grilName){
        this.choice = choice;
        this.grilName = grilName;
    }

    @Override
    public void run() {
        try {
            makeUp();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void makeUp () throws InterruptedException {
        if(choice ==0){
            //获得口红
            synchronized (lipstick){
                System.out.println(this.grilName + "获得口红");

                Thread.sleep(1000);
                //获得镜子
                synchronized (mirror){
                    System.out.println(this.grilName + "获得镜子");
                }
            }
        }else {
            //获得镜子
            synchronized (mirror){
                System.out.println(this.grilName + "获得镜子");
                Thread.sleep(1000);
                //获得镜子
                synchronized (lipstick){
                    System.out.println(this.grilName + "获得口红");
                }
            }
        }
    }
}

在这里插入图片描述
在这里插入图片描述

package com.thread.demo01;

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

public class LockTest {
    public static void main(String[] args) {
        BuyTicker01 buyTicker= new BuyTicker01();
        new Thread(buyTicker,"小明").start();
        new Thread(buyTicker,"大明").start();
        new Thread(buyTicker,"黄牛党").start();
    }
}

class BuyTicker01 implements Runnable{

    private int tickerName=10;

    private boolean flag = true;

    private Lock lock = new ReentrantLock();
    @Override
    public void run() {

            while(flag){
                lock.lock();
                try {
                    buy();
                }finally {
                    lock.unlock();
                }
            }



    }

    private  void buy(){
        if(tickerName<=0){
            flag = false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"===>拿到了"+tickerName--);
    }
}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.thread.demo01;

public class PcTest {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
         new Product(synContainer).start();
         new Consumer(synContainer).start();

    }

}
//生产者
class Product extends Thread{
    SynContainer synContainer;
    Product(SynContainer synContainer){
        this.synContainer =synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            synContainer.push(new Chicken(i));
            System.out.println("生产了第"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends  Thread{
    SynContainer synContainer;
    Consumer(SynContainer synContainer){
        this.synContainer =synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了第"+synContainer.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    int id; //产品编号

    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //容器
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count =0;
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        // 容器满了，就需要等待消费者消费
        if(chickens.length == count){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //容器没有满，生产者生茶
        chickens[count] = chicken;
        count++;
        //可以通知消费者消费
        this.notifyAll();

    }

    public synchronized Chicken pop(){
        //判断是否可以消费
        if(0 == count){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 可以消费
        count--;
        this.notifyAll();
        return chickens[count];
    }
}

在这里插入图片描述

package com.thread.demo01;

public class PcTest02 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者 演员
class Player extends Thread{
    Tv tv;
    Player(Tv tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.tv.play("西游记");
            }else {
                this.tv.play("三国演义");
            }
        }
    }
}
// 消费者 观众
class Watcher extends Thread{
    Tv tv;
    Watcher(Tv tv){
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
           this.tv.watch();
        }
    }
}
// 产品 节目
class Tv{
    String voice; //表演节目
    boolean flag = true;

    //表演
    public synchronized void  play(String voice){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了："+voice);
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;
    }
    //观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了："+this.voice);
        this.notifyAll();
        this.flag = true;
    }
}

在这里插入图片描述
在这里插入图片描述

package com.thread.demo01;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolTest {

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.shutdown();
    }
}
class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
树》》》新时代码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java并发（二十四）多线程结果组装
08-05
1.0 博文链接：https://phl.iteye.com/blog/2035708
Java代码实现多级目录树的封装(转)
u010860697的博客
08-27 2971
我们经常在代码里会造一个树结构对象，以方便前端使用。 以地区（区、镇、村）为例  后台一般对于树结构对象在数据库的结构是这样的： 主键ID 名字 父ID ID REGION_NAME PARENT_ID 121100 尼龙区 0 121100001 尼龙区钢丝镇 121100 121100001001 尼龙区钢丝镇螺丝村 ...
java实现多层级目录树详解
热门推荐
zhenghuishengq的博客
10-08 1万+
java实现多层级目录树
基于递归算法使用单线程、多线程输出目录树
qq_35606401的博客
04-23 866
1、目标：输出类似 Windows 的命令行工具中 tree /F 命令所得到的目录树： 2、语言、算法： 所使用的计算机语言：Java 涉及算法：递归算法 涉及的类库：java.io.File、java.util.ArrayList 3、思路分析： 自定义一个简单的链表类，作为存储目录树的结构； 写一个递归算法先把文件夹目录结构存储在目录树中； 再写一个目录树遍历方法，传入一个根节点，按照目录树的结构输出整个目录树； 分别使用单线程、多线程实现此功能； 在线程开始时和线...
多线程案例之遍历二叉树
进击的小白
09-05 2025
多核（如4核）CPU最高效遍历二叉树 思路：创建核心线程数为4的线程池，从上到下遍历二叉树，逢左节点创建新线程计算并加入线程池，当前线程计算所有右节点。 package com.lizz.fundation.leetcode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.concurr...
Java多线程详解及示例
最新发布
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
java多线程，对多线程，线程池进行封装，方便使用
05-16
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，我们可以通过实现Runnable接口或继承Thread类来创建线程。然而，直接使用线程可能存在一些问题，如资源管理...
Java多线程结构_Java多线程结构_
09-30
Java多线程结构是Java编程中的重要组成部分，它允许程序同时执行多个任务，提升系统效率。在Java中，实现多线程主要有两种方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当自定义类继承Thread类时，...
java线程深入_Java深入学习（1）：多线程
weixin_39569051的博客
02-26 48
多线程目的：在同一时刻有多条不同路径执行程序，提高程序运行效率多线程应用：数据库连接池，多线程文件下载等注意：在文件下载中使用多线程，无法提高速度在一个进程中，一定会有主线程从基础开始，多线程的使用方式：1.继承Thread类：(不推荐)public class ThreadDemo extendsThread {@Overridepublic voidrun() {//写入线程执行的代码}pub...
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
java多线程进阶
10-18
Java多线程是Java编程中的核心概念，尤其对于高级开发者来说，掌握多线程的深入理解和应用至关重要。这本书“java多线程进阶”显然旨在帮助读者深化这方面的理解，打通编程中的“任督二脉”，使开发者能够更加熟练地...
Java多线程深度解析
"Java多线程全套教程，涵盖了从基础到高级的多线程知识，包括线程的概念、创建方式、CPU调度以及线程池的使用。" Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高程序的运行效率。在深入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值