java线程初识(一)

已于 2023-07-28 17:11:24 修改
阅读量534 收藏
点赞数 1
分类专栏： 笔记 线程进程 javaEE 文章标签： java java-ee ide
于 2023-02-23 17:53:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_53679373/article/details/129183742
版权

目录

1.认识线程

        1.1线程是什么

        1.2为什么要有线程

        1.3线程和进程的区别

        1.4java的线程和操作系统线程的区别

2.创建线程

        2.1继承Thread类

        2.2实现Runnable接口

        2.3匿名内部类创建Thread子类对象

        2.4匿名内部类创建Runnable子类对象

        2.5lambda表达式创建Runnable子类对象

3.Thread类及常见方法

        3.1Thread的常见构造方法及属性

        3.2线程中的start()和run()区别

        3.3中断一个线程

        3.4等待一个线程

        3.5休眠一个线程

4.线程的状态

        4.1线程的所有状态

1.认识线程

1.1线程是什么

  一个线程就是一个"执行流"，每个线程都可以按照顺序执行自己的代码，多个线程之间执行着多个代码。 线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器，一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

1.2为什么要有线程

--单核cpu的发展遇到了瓶颈，想要提高算力，就要多核cpu，而并发程序可以更好的利用cpu资源

--有部分任务场景需要"等待IO"，为了让等待IO的时间可以去处理一些其他的事务，也需要使用到并发编程

虽然多进程也可以实现并发编程，但是线程比进程更加轻量

--创建线程比创建进程更快

--销毁线程比销毁进程更快

--调度线程比调度进程更快

1.3线程和进程的区别

--进程中包含线程，每一个进程都至少有一个线程(主线程)

--进程是申请系统资源的最小单位，线程是cpu调度的最小单位

--线程之间可以共享进程申请的系统资源

--一个线程如果崩溃了，就会影响到进程

--一个进程中可以有多个线程，多个线程共享进程的堆和方法区资源，但是每个线程有自己的程序计数器，虚拟机栈和本地方法栈。

1.4java的线程和操作系统线程的区别

  在java中创建一个线程对象-->jvm调用系统的api-->创建一个真正的操作系统中的线程，这个过程是在cpu上执行任务的线程。

  操作系统中线程是通过操作系统中的线程PCB，是对PCB做了一个抽象。

2.创建线程

2.1继承Thread类

public class demo_101 {
    public static void main(String[] args) {
        //实例化线程对象
        mythread mythread01=new mythread();
        mythread01.start();
    }
}
//通过继承thread类的方式创建一个线程
//重写run方法就是去指定线程要执行的任务
class mythread extends Thread{
    @Override
    public void run() {
        System.out.println("hello Thread!");
    }
}

2.2实现Runnable接口

public class boke {
    public static void main(String[] args) {
        myrunnable demo=new myrunnable();
        Thread thread=new Thread(demo);
        thread.start();
    }
}
class myrunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("实现runnable接口");
    }
}

2.3匿名内部类创建Thread子类对象

//通过创建Thread类的匿名内部类的方式创建线程
public class demo_104 {
    public static void main(String[] args) {
        Thread thread=new Thread(){
            @Override
            public void run() {
                while (true){
                    System.out.println("通过创建Thread类的匿名内部类的方式创建线程");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        //启动线程
        thread.start();
    }
}

2.4匿名内部类创建Runnable子类对象

//通过创建实现了runnable接口的匿名内部类的方式创建线程
public class demo_105 {
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                int count=0;
                while (true){
                    count++;
                    System.out.println("通过创建实现了runnable接口的匿名内部类的方式创建线程"+count);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        thread.start();
    }
}

2.5lambda表达式创建Runnable子类对象

//通过lambda表达式的方式创建线程
public class demo_106 {
    public static void main(String[] args) {
        Thread thread=new Thread(() ->{
            int count=0;
            while (true){
                count++;
                System.out.println("通过lambda表达式的方式创建线程"+count);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread.start();
    }
}

3.Thread类及常见方法

3.1Thread的常见构造方法及属性

方法注释
Thread()创建线程对象
Thread(Runnable target)使用Runnable对象创建线程对象
Thread(String name)创建线程对象并命名
Thread(Runnable target,String name)使用Runnable对象创建线程对象并命名
属性获取方法
IDgetID()
名称getName()
状态getState()
优先级getPriority()
是否后台线程isDaemon()
是否存活isAlive()
是否被中断isInterrupted()
public class legion04 {
    public static void main(String[] args) {
        Thread thread=new Thread(() ->{
            while (true){
                System.out.println("hello thread...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"大蛇");
        thread.start();
        System.out.println("线程的ID:"+thread.getId());
        System.out.println("线程的名字:"+thread.getName());
        System.out.println("线程的状态:"+thread.getState());
        System.out.println("线程的优先级:"+thread.getPriority());
        System.out.println("线程是否后台:"+thread.isDaemon());
        System.out.println("线程是否存活:"+thread.isAlive());
        System.out.println("线程是否中断:"+thread.isInterrupted());
    }
}

3.2线程中的start()和run()区别

  在前面的代码中，我们都重写了 Thread 类或者 Runabble 接口的 run() 方法。并在 run() 方法中定义这个线程需要完成的指令。但是启动线程时不是直接去调用线程实例的 run() 方法，而是通过调用 start() 方法来启动线程。需要注意的是，调用了 start() 方法后，线程可能不会立即执行，它需要等待 cpu 来调度。cpu 在处理该线程的任务时，其实就是执行我们定义的 run() 方法。只有调用了start()方法，才真的在操作系统的的底层创建出了一个线程

3.3中断一个线程

中断一个线程目前常用的方式有两种

1.通过共享的标记进行中断

//通过共享的标记进行中断
public class legion05 {
    private static boolean ispick=false;
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(() ->{
            while (!ispick){
                System.out.println("hello  thread...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行完成");
        });
        System.out.println("线程启动之前线程状态"+thread.getState());
        System.out.println("线程启动之前是否存活"+thread.isAlive());
        thread.start();
        System.out.println("线程启动之后线程状态"+thread.getState());
        System.out.println("线程启动之后是否存活"+thread.isAlive());
        Thread.sleep(5000);
        ispick=true;
        Thread.sleep(1000);
        System.out.println("中断之后线程状态"+thread.getState());
        System.out.println("中断之后是否存活"+thread.isAlive());
    }
}

2.通过调用interruputed()方法来中断

//通过调用interruputed()方法来中断
public class legion06 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(() ->{
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("hello  thread...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
            System.out.println("线程执行完成");
        });
        System.out.println("线程启动之前线程状态"+thread.getState());
        System.out.println("线程启动之前是否存活"+thread.isAlive());
        thread.start();
        Thread.sleep(500);
        System.out.println("线程启动之后线程状态"+thread.getState());
        System.out.println("线程启动之后是否存活"+thread.isAlive());
        Thread.sleep(1000);
        thread.interrupt();
        System.out.println("中断之后线程状态"+thread.getState());
        System.out.println("中断之后是否存活"+thread.isAlive());
    }
}

3.4等待一个线程

等待一个进程，意味着等待线程完成它的所有工作后，才可以进行下一步工作

public class legion07 {
    public static void main(String[] args)  {
        Thread thread=new Thread(() ->{
            for (int i = 0; i < 5; i++) {
                System.out.println("hello thread...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        System.out.println("join()执行前:"+Thread.currentThread().getState());
        System.out.println("join()执行前:"+thread.isAlive());
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("join()执行后:"+Thread.currentThread().getState());
        System.out.println("join()执行后:"+thread.isAlive());
        System.out.println("主线程执行完成");
    }
}

 3.5休眠一个线程

   我们以上的代码多数使用了sleep()方法，为了使运行结果更为直观

  当我们需要使一个线程进入睡眠的时候，那么我们就需要使用到sleep()方法。sleep()方法是一个静态方法,调用时，我们只需要直接使用 “类名.sleep()” 就可以调用该方法。

  Thread.sleep(long millis)方法的参数是一个long类型的毫秒数

  如果是将sleep()方法写在A线程下,那么调用该方法的就是A线程
  如果是将sleep()方法写在B线程下,那么调用该方法的就是B线程

4.线程的状态

4.1线程的所有状态

1.初始状态（NEW）

线程以及构建，但是还没有调用start()方法

2.运行状态（RUNNABLE）

java线程把操作系统中就绪和运行两种运行状态都称为"运行中"

3.阻塞状态（BLOCKED）

表示线程进入等待状态，也就是线程因为某种原因放弃了CPU的使用权，阻塞也分为几种情况

                等待阻塞：运行的线程执行了Thread.sleep、wait、join等方法，JVM会把当前线程设置为等待状态，当sleep结束，join线程终止或者线程被唤醒后，该线程从等待状态进入阻塞状态，重新占用锁后进行线程恢复

                 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其他线程锁占用了，那么JVM会把当前项城放入到锁池中

                 其他阻塞：发出I/O请求，JVM会把当前线程设置为阻塞状态，当I/O处理完毕则线程恢复
4.等待状态（WAITING）

等待状态，没有超时时间（无限等待），要被其他线程或者有其他的中断操作

执行wait、join、LockSupport.park()

5.超时等待（TIME_WAITING）

与等待不同的是，不是无限等待，超时后自动返回

执行sleep，带参数的wait等可以实现

6.终止（TEMINATED）

代表线程执行完毕

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北~笙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值