20240423-线程基础

创建线程的三种方法

继承Thread

java 复制代码
package com.ysf;

import java.util.concurrent.TimeUnit;

public class ThreadWay {

    public static void main(String[] args) throws InterruptedException {
        Hello t = new Hello();
        t.start();
        TimeUnit.SECONDS.sleep(3L);
    }

    static class Hello extends Thread{
        public void run(){
            System.out.println("hello");
        }
    }
}

实现Runnable

java 复制代码
package com.ysf;

import java.util.concurrent.TimeUnit;

public class RunableWay {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Test());
        thread.start();
        TimeUnit.SECONDS.sleep(10L);
    }

    static class Test implements Runnable{

        public void run() {
            System.out.println("hello");
        }
    }
}

实现Callable使用FutureTask

java 复制代码
package com.ysf;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableWay {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> task = new FutureTask<>(new Tst());
        Thread thread = new Thread(task);
        thread.start();
        System.out.println(task.get());
    }

    static class Tst implements Callable<Integer>{

        public Integer call() throws Exception {
            int a = 0;
            for (int i=0;i<100;i++){
                a +=i;
            }
            return a;
        }
    }
}

线程的状态

NEW状态

java 复制代码
package com.ysf;

public class Tst01NEWState {

    public static void main(String[] args) {
        Thread t = new Thread(()->{});
        System.out.println(t.getState());
    }
}

RUNNABLE状态

java 复制代码
package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst02RUNNABLEState {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (true){}
        });
        t.start();
        TimeUnit.SECONDS.sleep(20L);
        System.out.println(t.getState());
    }
}

BLOCKED状态

java 复制代码
package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst03BLOCKState {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            // t线程在获取锁的时候阻塞,因为锁已经被主线程拿走了
           synchronized (Tst03BLOCKState.class){

           }
        });

        // 主线程拿锁后启动t线程
        synchronized (Tst03BLOCKState.class){
            t.start();
            TimeUnit.SECONDS.sleep(2L);
            System.out.println(t.getState());
        }
    }
}

WAITING状态

  • wait状态必须手动唤醒
java 复制代码
package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst04WaitState {

    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        Thread t = new Thread(()->{
            synchronized (obj){
                try {
                    // 调用wait方法等待,wait方法一定要手动唤醒
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        t.start();
        TimeUnit.SECONDS.sleep(2L);
        System.out.println(t.getState());
    }
}

TIMED_WAITING

  • 调用sleep或join方法
java 复制代码
package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst05TimedWaiting {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            try {
                // t休眠1秒
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
        // 主线程休眠0.5秒
        TimeUnit.MILLISECONDS.sleep(500L);
        // 此时t应仍在休眠,因此getState方法应为TIMED_WAITING状态
        System.out.println(t.getState());
    }
}

TERMINATED状态

java 复制代码
package com.ysf;

import java.util.concurrent.TimeUnit;

public class Tst06Terminated {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            try {
                // t休眠0.5秒
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
        // 主线程休眠1秒
        TimeUnit.MILLISECONDS.sleep(1000L);
        // 此时t应执行结束了,因此getState方法应为TERMINATED状态
        System.out.println(t.getState());
    }
}

线程的常用方法

获取当前线程

java 复制代码
package com.ysf;

public class Tst07CurrentThread {

    public static void main(String[] args) {
        Thread main = Thread.currentThread();
        // 获取并打印当前线程
        // 输出结果:Thread[main,5,main]
        // 线程名,优先级,组名
        System.out.println(main);
    }
}
相关推荐
蝈蝈噶蝈蝈噶3 分钟前
问题:tomcat下部署eureka双重路径
java·eureka·tomcat
禹曦a7 分钟前
Java进阶之旅-day05:网络编程
java·开发语言·网络
五行星辰28 分钟前
Gson修仙指南:谷歌大法的佛系JSON渡劫手册
java·后端
哈哈哈哈哈哈哈哈哈...........33 分钟前
【无标题】object,wait,notifyAll
java·开发语言
Niuguangshuo39 分钟前
Python 设计模式:迭代模式
java·python·设计模式
1ven44 分钟前
JDBC驱动包的隔离加载与卸载
java
Richard20121 小时前
Java 源码 - Atomic包中的原子操作类总结
java
Richard20121 小时前
Java 源码 - 本地变量ThreadLocal
java·面试
码哝小鱼2 小时前
docker swarm常用命令
java·docker·eureka