首页 > 其他分享 >多线程Day02

多线程Day02

时间：2024-10-01 20:49:23浏览次数：1  
标签：Day02 void System 线程 println 多线程 public out

静态代理

package com.dongfangyulv.demo01;

//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处：
//代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情

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

        You you = new You();//你要结婚

        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.Marry();
    }
}

interface Marry{

    void Marry();
}

//真实角色
class You implements Marry{
    @Override
    public void Marry() {
        System.out.println("新婚快乐");
    }
}

//代理角色
class WeddingCompany implements Marry{

    //代理真实目标角色
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void Marry() {
        before();
        this.target.Marry();//这就是真实对象
        after();
    }

    private void before() {
        System.out.println("结婚前");
    }

    private void after() {
        System.out.println("结婚后");
    }
}

Lamda表达式

  • 避免匿名内部类过多

  • 实质属于函数式编程的概念

    • 函数式接口：任何接口如果只包含一个抽象方法，那么他就是一个函数式接口

      public interface Runnable{
    public abstract void run();
}

  • 去掉了一堆没有意义的代码，只留下核心的逻辑

package com.dongfangyulv.lambda;
/*
推导lamda表达式
*/
public class TestLambda1 {

    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.lambda();

        //5.匿名内部类，没有类的名称，必须借助接口或者父类
        like = new ILike(){
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();

        //6.用lambda简化
        like = () -> {
            System.out.println("I like lambda5");
        };
        like.lambda();
    }
}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda1");
    }
}

package com.dongfangyulv.lambda;

public class TestLambda2 {

    public static void main(String[] args) {
        ILove love = null;

        //Lambda表示简化
        love = (int a) ->{
            System.out.println("I love you" + a);
        };

        //简化1.参数类型
        love = (a) ->{
            System.out.println("I love you" + a);
        };

        //简化2.简化括号
        love = a ->{
            System.out.println("I love you" + a);
        };

        //简化3.去花括号
        love = a -> System.out.println("I love you" + a);

        //总结：
        //Lambda表达式只能有一行代码的情况下才能简化，如果有多行代码，就用代码块包裹
        //前提是接口为函数式接口
        //多个参数也可以去掉参数类型，要去就都去了，必须加上括号

        love.love(520);
    }
}

interface ILove{
    void love(int a);
}

线程状态

  • new

    尚未启动的线程

  • runnable

    在Java虚拟机中执行的线程

  • blocked

    被阻塞等待监视器锁定的线程

  • waiting

    正在等待另一个线程执行特定动作的线程

  • timed_waiting

    正在等待另一个线程执行动作达到指定等待时间的线程

  • terminated

    已退出的线程

线程停止

  • 不推荐使用JDK提供的stop( )、destory( )方法
  • 推荐线程自己停止下来
  • 建议使用一个标志位进行终止变量，当flag = false，则终止线程运行
package com.dongfangyulv.state;

//测试stop
//1.建议线程正常停止--->利用次数，不建议死循环
//2.建议使用标志位--->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
    //1.设置一个标志位
    private boolean flag = true;

    @Override
    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 < 100; i++) {
            System.out.println("main" + i);
            if (i == 90){
                //调用stop方法，切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程停止了");
            }
        }
    }
}

线程休眠

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

import java.text.SimpleDateFormat;
import java.util.Date;

//模拟网络延时：放大问题的发生性
public class TestSleep {
    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();
            }
        }

//        模拟倒计时
//        try {
//            tenDown();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
    }

    //模拟倒计时
    public static void tenDown() throws InterruptedException{
        int num = 10;

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

线程礼让

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让CPU重新调度，礼让不一定成功，看CPU心情
package com.dongfangyulv.state;

//测试礼让线程
//礼让不一定成功，看CPU心情
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}

class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();//线程礼让
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }
}

线程强制执行

  • Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
package com.dongfangyulv.state;

//测试Join方法
//插队
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; 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);
        }
    }
}

线程状态观测

package com.dongfangyulv.state;

//观察测试线程的状态
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(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
    }
}

标签：Day02,void,System,线程,println,多线程,public,out
From： https://www.cnblogs.com/dongfangyulv/p/18443282

相关文章

  • 快速排序算法及多线程试验
    1）快速排序算法算法实现：选定一个起点/终点位置上的数A小于数A的放在A左侧，大于的放在右侧对A左侧和右侧数组递归的执行步骤2//分区函数template<typenameT>intpartition(Tarr[],intlength){ if(length<=1) return1; inti=1; intj=length-1; //se......
  • 【多线程奇妙屋】 Java 的 Thread类必会小技巧，教你如何用多种方式快速创建线程，学并发
    本篇会加入个人的所谓鱼式疯言❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言而是理解过并总结出来通俗易懂的大白话,小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的.......
  • 多线程Day01
    多线程线程、进程、多线程程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义，线程是CPU调度和执......
  • redis: 开启io多线程
    一，配置redis.conf[root@webconf]#viredis.conf修改两个参数#Soforinstanceifyouhaveafourcoresboxes,trytouse2or3I/O#threads,ifyouhavea8cores,trytouse6threads.Inorderto#enableI/Othreadsusethefollowingconfigurationdire......
  • 【多线程】多线程（1）：概念，创建线程
    【多线程的概念】之前写过的所有代码，都只能使用“一个核心”，此时无论如何优化代码，最多只能用一个cpu核心，把这个核心跑满了，其他核心也是空闲着，通过写特殊的代码，把多个cpu核心都能应用起来，此为“并发编程”之前使用的并发模式为“多进程编程”，其在创建/销毁进程时开销较大，一旦......
  • 网络编程Day02
    通信协议网络通信协议：速率、传输码率、代码结构、传输控制...问题：非常的复杂分层：大事化小TCP/IP协议簇：实际上是一组协议TCP：用户传输协议UDP：用户数据报协议IP：网络互联协议TCPUDP对比TCP：打电话连接，稳定三次握手，四次分手最少需要三次，保证稳定连接最少需要四次......
  • C#实现多线程的几种方式
    前言多线程是C#中一个重要的概念，多线程指的是在同一进程中同时运行多个线程的机制。多线程适用于需要提高系统并发性、吞吐量和响应速度的场景，可以充分利用多核处理器和系统资源，提高应用程序的性能和效率。多线程常用场景CPU密集型任务.I/O密集型任务.并发请求处理.大数......
  • 多线程学习
    一.认识线程（Thread）1.线程是什么定义：线程是一个轻量级的执行流，它代表了程序执行的一个路径。每个线程都有自己的程序计数器、栈和局部变量，但线程之间可以共享同一个进程的全局变量和堆。主线程：在Java程序中，main()方法所运行的线程被称为主线程（MainThread）。当你启动......
  • python多线程与线程池
    线程：是任务的执行者。进程：是一个动态的概念。适用情况：IO密集用多线程。CPU密集用多进程。原因：Cpython解释器中使用了GIL全局解释锁，一个进程只有一个锁。只有拿到这个锁的线程才能获取解释器，取解释执行代码。这就导致了即使开了多线程，实际上只有一个线程在执行。因此......
  • C++多线程与并发类面试题
    题目来源：https://subingwen.cn/cpp/thread/https://mp.weixin.qq.com/s?__biz=Mzg4NDQ0OTI4Ng==&mid=2247489580&idx=1&sn=b9ac83040601230ff897f3394e956cea&chksm=cfb95145f8ced8536d5dcfa7d3165e3a51f5cb40e52f699745df0d8f71e4f7591674cd5cf156&token=......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99