线程详解

最新推荐文章于 2023-05-28 14:12:46 发布
最新推荐文章于 2023-05-28 14:12:46 发布
阅读量53 收藏
点赞数
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50881929/article/details/115470990
版权

创建线程

线程开启不一定立即执行，由cpu调用 执行

方法1：继承Thread类，重写run方法，用start开启线程

package Thread.ThreadTest1;

public class Main {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        test1.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("Main"+i);
        }
    }
}
class Test1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("线程"+i);

        }
    }
}

方法：实现runnable接口，重写run方法

package Thread.ThreadTest2;

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableTest());
        thread.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("Main"+i);

        }
    }
}
class RunnableTest implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("Runnable "+ i);
        }
    }
}

一个对象被多个线程同时使用

package Thread.ThreadTest3;

public class Main {
    public static void main(String[] args) {
        ThreadTest thread = new ThreadTest();
          new Thread( thread, "小明").start();
          new Thread( thread, "老师").start();
          new Thread( thread, "黄牛").start();

    }
}
class ThreadTest implements Runnable{
    private  int ticket = 10;
    @Override
    public void run() {
        while (true){
            if(ticket <=0){
                break;
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到第"+ticket--+"张票");
        }
    }
}

并发问题

龟兔赛跑

package Thread.ThreadTest4;

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

}

class Test implements Runnable {
    private String Winner;

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            boolean flag = gameOver(i);
            if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            if (flag) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
        }
    }

    //判断是否完成比赛
    private boolean gameOver(int step) {
        if (Winner != null) {
            return true;
        }
        {
            if (step == 100) {
                Winner = Thread.currentThread().getName();
                System.out.println("Winner is" + Winner);
                return true;
            }
        }
        return false;
    }
}

静态代理模式

  • 真实对象和代理对象都要实现一个接口
  • 代理对象代理真实角色

好处

  • 代理对象可以做很多真实对象做不了的事
  • 真实对象只需要做自己做的事
package Thread.TreadTest5;

public class Main {
    public static void main(String[] args) {
        Mother mother = new Mother(new Son());
        mother.eat();
    }
}
interface Eat {
    void eat();
}
class Son implements Eat {
    @Override
    public void eat() {
        System.out.println("开始吃饭");
    }
}
class Mother implements Eat{
    private Eat target;

    public Mother(Eat target) {
        this.target = target;
    }

    @Override
    public void eat() {
        before();
        this.target.eat();
        after();

    }

    private void after() {
        System.out.println("老妈开始做饭");
    }

    private void before() {
        System.out.println("老妈开始洗碗");
    }
}

lambda表达式

  • lambda表达式只有在一行代码的时候才能简化为一行，如果有多行，需用代码块包裹
  • 前提是这个接口为函数式接口
  • 这个参数也可以去掉参数类型，要去掉就都去掉
package Thread.LambdaTest;

public class Main {
    /* //静态内部类
     static class Son implements Eat{
         @Override
         public void eat(int a,int b) {
             System.out.println("I like Eat"+a);
             System.out.println("I like Eat"+b);
         }

     }
   */
    public static void main(String[] args) {
        //lambda表达式
        Eat eat1 = (int a, int b,int c) -> {
            System.out.println("I like Eat" + a);
            System.out.println("I like Eat" + b);
            System.out.println("I like Eat" + c);
        };
        eat1.eat(10,20,30);
    }
}

interface Eat {
    void eat(int a, int b,int c);
}

线程使用

线程停止

package Thread.StopTest;

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        new  Thread(test).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("Main"+i);
            if (i==900){
                test.stop();
                System.out.println("线程该停止了");
            }

        }
    }
}
class Test implements Runnable{
    boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("Thread" + i);
            i++;
        }
    }
    void stop(){
        this.flag = false;
    }
}

线程休眠

package Thread.SleepTest;

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

//模拟倒计时
public class Main {
    public static void main(String[] args) {
        try {
            test();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    static void test() throws InterruptedException {
        Date date = new Date(System.currentTimeMillis());
        while (true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH,mm,ss").format(date));
            date = new Date(System.currentTimeMillis());
            }
        }

}

线程礼让

package Thread.YieldTest;

public class Main {
    public static void main(String[] args) {
        new Thread(new MyYield(),"a").start();
        new Thread(new 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()+"停止执行");
    }
}

线程强制执行

package Thread.JoinTest;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        //启动自定义线程
        test test = new test();
        Thread thread = new Thread(test);
        thread.start();
        //启动主线程
        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                thread.join();
            }
            System.out.println("Main线程" + i);

        }
    }

}

class test implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("vip来了" + i);

        }
    }
}

线程优先使用

package Thread.SetPriorityTest;

public class Main {
    public static void main(String[] args) {
        //最先往往是main函数再运行
        Test test = new Test();
        Thread t1 = new Thread(test,"线程1");
        Thread t2 = new Thread(test,"线程2");
        Thread t3 = new Thread(test,"线程3");
        Thread t4 = new Thread(test,"线程4");
        System.out.println(Thread.currentThread().getName() + "在运行" + Thread.currentThread().getPriority());

        t1.start();
        t2.setPriority(10);
        t2.start();
        t3.setPriority(1);
        t3.start();
        t4.setPriority(5);
        t4.start();
    }
}

class Test implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "在运行" + Thread.currentThread().getPriority());
    }
}

守护线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
package Thread.SetPriorityTest.ProtectThreadTest;

public class Main {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        Thread thread = new Thread(god);
        thread.setDaemon(true);
        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("这是你开心生活的第"+i+"天");
        }
        System.out.println("goodbye world!");
    }
}

锁

不安全的线程

  • 不安全的买票
  • 线程不安全，有负数
package Thread.SetPriorityTest.SynchorizedTest;

public class UnSafeTest {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
         new Thread(buyTicket,"学生").start();
         new Thread(buyTicket,"老师").start();
         new Thread(buyTicket,"黄牛").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();
              }
          }
     }
     void buy() throws InterruptedException {
          if(TicketNum <=0){
              flag = false;
              return;
          }
          Thread.sleep(5);
         System.out.println(Thread.currentThread().get+"买到"+TicketNum--);
     }

 }

UnsafeList

package Thread.SynchorizedTest.UnSafeList;

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ArrayList<Object> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{list.add(Thread.currentThread().getName());}).start();
        }
        Thread.sleep(300);
        System.out.println(list);
    }
}

Synchronize锁

同步方法：解决线程安全，说明给方法加锁，锁对象是方法的对象

悲观锁
package Thread.SynchorizedTest.UnSafeBuyTicket;

public class Main {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket, "老师").start();
        new Thread(buyTicket, "黄牛").start();
        new Thread(buyTicket, "学生").start();
    }
}

class BuyTicket implements Runnable {
    private int TicketNum = 100;
    boolean flag = true;

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

     synchronized void buy() throws InterruptedException {
        if (TicketNum <= 0) {
            flag = false;
            return;
        }
        Thread.sleep(500);
        System.out.println(Thread.currentThread().getName() + "买到" + TicketNum--);
    }

}
同步代码块
package Thread.SynchorizedTest.UnSafeBuyTicket;

public class Main {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket, "老师").start();
        new Thread(buyTicket, "黄牛").start();
        new Thread(buyTicket, "学生").start();
    }
}

class BuyTicket implements Runnable {
    private int TicketNum = 100;
    boolean flag = true;

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

      void buy() throws InterruptedException {
        if (TicketNum<=1) {
            flag = false;
            return;
        }
        Thread.sleep(30);
        synchronized (this){
            //可能出现安全的代码
            System.out.println(Thread.currentThread().getName() + "买到" +  TicketNum);
            TicketNum = TicketNum-1;

        }
    }

}

死锁

产生死锁的四个必要条件:

  • 互斥条件：一个资源每次只能被一个进程使用

  • 请求与保持条件：一个进程因请求资源二阻塞时，已获得的资源保持不放

  • 不剥夺条件：进程已获得资源，在未使用完之前，不能强行剥夺

  • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

package Thread.SynchorizedTest.DeadLock;

public class Main {
    public static void main(String[] args) {
        new Eat(1,"小明").start();
        new Eat(0,"小红").start();
    }
}
class Chopsticks{}
class Dish{}
class Eat extends Thread{
    static Chopsticks chopsticks = new Chopsticks();
    static Dish dish = new Dish();
    int choice;
    String name;
    Eat(int choice,String name){
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        try {
            eat();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    void eat() throws InterruptedException {
        if (choice == 0){
            synchronized (dish){
                System.out.println(name+"拿到了盘子");
                Thread.sleep(2000);
            }
            synchronized (chopsticks){
                System.out.println(name+"拿到筷子");
            }
        }else {
            synchronized (chopsticks){
                System.out.println(name+"拿到了筷子");
                Thread.sleep(1000);
            }
            synchronized (dish){
                System.out.println(name+"拿到盘子");
            }
        }
    }
}

线程池

package Thread.ExecutorSeriveTest;

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

public class Main {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new test());
        service.execute(new test());
        service.execute(new test());
        service.execute(new test());
    }
}
class test implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
阿鬼大大
关注
专栏目录
Java多线程详解及示例
07-20
守护线程（Daemon Thread）是一种特殊线程，当所有非守护线程结束时，守护线程也会随之结束，通常用于后台服务。 总结： Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步...
02-面向对象—＞高级—＞练习
海绵猿宝的博客
04-02 780
public class main { public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println("账号："); String a = input.nextLine(); System.out.println("密码："); String b = input.nextLine().
R7-17 程序填空题2
hu_66666的博客
05-09 905
补全以下程序，使得程序输出结果与下述结果一致。 public class Main { public static void main(String[] args) { Test test = new Test(true); } } class Test { public Test(){ System.out.println("Constructor one invoked!"); } public Test(int x){
（二）java虚拟机——常用java虚拟机参数
Haward
09-10 268
读懂GC日志 （1）代码： public class Main { public static void main(String[] args) { TestClass testClass = new TestClass(); testClass.localvar1(); testClass.localvar2(); } } class TestClass { ...
7-1 程序填空题2 (12分)
sddfnsff的博客
06-14 5199
补全以下程序，使得程序输出结果与下述结果一致。 public class Main { public static void main(String[] args) { Test test = new Test(true); } } class Test { public Test(){ System.out.println(“Constructor one invoked!”); } public Test(int x){ //此处添加代码 System.out.println(“Constructor
public static void main(String[] args){} 关于Java main()方法
热门推荐
开着奥迪卖小猪
06-30 1万+
是Java程序的入口方法，JVM在运行程序时，会首先查找main()方法。 　　public是权限修饰符，表明任何类或对象都可以访问这个方法； 　　static表明main()方法是一个静态方法，即方法中的代码时存储在静态区的，只要类被加载后，就可以使用该方法而不需要通过实例化对象来访问，可以直接通过 类名.main() 直接访问； 　　void表明方法没有返回值； 　　main是JVM识别的特殊
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
Java多线程详解
01-20
文章目录1、进程与线程2、创建多线程2.1、继承Thread类2.2、实现Runnable接口2.3、使用匿名内部类实现2.4、实现Runnable接口的好处2.5、使用Callable和Future创建线程3、线程的生命周期4、几种特殊线程4.1、join线程...
Python多线程详解
01-27
一个进程至少包含一个线程。线程有5种状态，状态转换的过程如下图所示：多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。考虑这样一种情况：一...
Java面向对象（下篇）
qq_59336423的博客
05-25 96
单例设计模式： 1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。 2.如何实现？ 饿汉式 VS 懒汉式 package com.atuigu.java2; //饿汉式 public class SingletonTest { public static void main(String[] args) { Bank bank1 = Bank.getInstance(); Bank bank2 = Bank.getInstance();
应届生JAVA面试笔试选择题（答案+解析）
qq_40959369的博客
03-08 1万+
Java基础 Java语言中下面那个可以用作正确的变量名称？ A.name B.3D C.implements D.extends JDBC中，用于表示数据库连接的对象是 A．Statement　B．Connection　C. DriverManager　D．PreparedStatement 下列说法正确的是？ A.一个文件里可以存在两个public修饰的类 B，final修饰的类可以被继承 C，子类不...
java 基础题目--01
最后的武艺集大成者
01-15 746
  1.输出结果多少？ class Test { public static void main(String[] args) { System.out.println(new B().getValue()); } static class A { protected int value; public A (int v...
第三章 面向对象 题库
最新发布
qq_74940664的博客
05-28 3657
解析：所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问，为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx方法和设置属性值的setXxx方法。父类的构造在子类中没有返回类型，方法名也与子类的类名不相同。Java虚拟机会自动为成员变量进行初始化，针对不同类型的成员变量，Java虚拟机会赋予不同的初始值，如int类型的成员变量初始值为0，long类型的成员变量初始值为0L。
牛客网—Java练习题
TingtingYang
07-04 5965
PAT乙级Basic Level真题1. 1001 A+B和C (15)1.1 题目1.2 题目解析1.3 程序2. 数字分类 (20)2.1 题目2.2 题目解析2.3 程序 为了记录日常的Java学习，我专门开了这个帖子，记下自己的刷题之路。此帖子的题目来源于牛客网，详见。 1. 1001 A+B和C (15) 1.1 题目 可点击此处查看原题目 1.2 题目解析 这个题目需要注意的大概有一...
volatile 可见性代码示例
yaobo2816的专栏
12-21 280
public class Test { public volatile int a =0; public void add(){ this.a = 20; } } import java.util.concurrent.TimeUnit; public class Main { public static void main(String[] args) { Test test = new Test(); ne.
[知行]Java题库
文艺倾年的博客
08-31 1691
文章目录励志2021.8.20月总结： 励志 日积月累，每天进步一点点！ 2021.8.20 1.指出下列程序运行的结果： public class Example{ String str=new String("tarena"); char[]ch={'a','b','c'}; public static void main(String args[]){ Example ex=new Example(); ex.change(ex.str,ex
7-18 程序填空题2
懒懒猪
04-02 229
补全以下程序，使得程序输出结果与下述结果一致。
JAVA实验四
qq_45743814的博客
05-04 1383
JAVA实验四 实验四一共八题，附上题目及完整代码。 7206 题目內容: 输入一个字符串,在输入一个字符 (1)在字符串中删除指定的字符并输出 (2)把(1)中得到的串逆序输出 输入输出说明: 输入： goodagoodagood a 输出： goodgoodgood doogdoogdoog 代码编辑: import java.util.Scanner; public class Main { public static String reverse(String str){ .
Delphi多线程详解：创建与应用实践
Delphi多线程详解深入探讨了在Delphi编程中实现多线程的各个方面。章节11首先定义了线程的基本概念，指出在Win32操作系统中，线程是表示进程中执行路径的对象，每个应用程序至少有一个主线程，但可以通过创建额外...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值