Java多线程基础-学习之路(1)

最新推荐文章于 2024-07-14 22:18:32 发布

save_TT

最新推荐文章于 2024-07-14 22:18:32 发布

阅读量124

点赞数

分类专栏： java基础文章标签： java 多线程 thread

本文链接：https://blog.csdn.net/qq_44080203/article/details/107002692

版权

java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Java多线程基础(1)

1.多线程的概念

1.1.进程和线程的区别：

1.本质：每一个进程都有一套自己的一整套变量，而进程则共享数据。可以把进程看成火车，线程看成车厢，一个进程可以包含多个线程，共享变量使线程间的通信更有效，容易，同时线程与进程
比，线程更轻量级，创建，撤销比启动进程开销小的多。
2.使用线程是为了提高系统的执行效率，减少处理机的空转时间和调度切换的时间，以及便于系统管理。

1.2线程简介

线程的三个基本状态：

执行（Running），就绪（Runnable），阻塞（Blocked）。

线程的5个基本操作

派生，阻塞，激活，调度。

3.线程中的的几个常用方法

currentThread()

返回对当前正在执行的线程对象的引用。
getId()
返回此线程的标识符
getName()
返回此线程的名称
getPriority()
返回此线程的优先级
isAlive()
测试这个线程是否还处于活动状态。
什么是活动状态呢？
活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备运行的状态。
sleep(long millis)
使当前正在执行的线程以指定的毫秒数“休眠”（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。
interrupt()
中断这个线程。
interrupted() 和isInterrupted()
interrupted()：测试当前线程是否已经是中断状态，执行后具有将状态标志清除为false的功能
isInterrupted()：测试线程Thread对相关是否已经是中断状态，但部清楚状态标志
setName(String name)
将此线程的名称更改为等于参数 name 。
isDaemon()
测试这个线程是否是守护线程。
setDaemon(boolean on)
将此线程标记为 daemon线程或用户线程。
join()
在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。
join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行
yield()
yield()方法的作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU时间。注意：放弃的时间不确定，可能一会就会重新获得CPU时间片。
setPriority(int newPriority)
更改此线程的优先级

4、创建线程的方式

方式1 继承Thread，重写run方法
- 1.创建Thread类的子类即继承Thread，重写run方法
- 2.在创建Thread类的子类中重写Thread 的run()方法，设置线程任务（开启线程要做什么）
- 3.调用Thread 类中的start()方法，开启新的线程，执行run()方法
- 注意事项：多次启动一个线程是非法的，当线程关闭时，不能在重新启动。
方式2 实现Runnable接口，重写run方法
方式3 使用匿名内部类或者Lambda表达式实现创建线程
方式四通过线程池来创建（推荐）

1.1继承Thread，重写run方法

public class MyThread extends Thread {

    @Override
    public void run() {
        for (int x = 0; x < 20; x++) {
            System.out.println(x);
        }
    }
}

测试方法

public class MyThreadTest {
    public static void main(String[] args) {
        // 创建两个线程对象
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        my1.start();
        my2.start();
    }
}

1.2.实现Runnable接口，重写run方法

public class demoThread  implements Runnable{
    public static void main(String[] args) {

       demoThread dt=new demoThread();
        Thread th=new Thread(dt);
        Thread th1=new Thread(dt)
        th.start();  
        th1.start();
    }
        @Override
    public void run() {
        for(int i=0;i<20;i++)
            System.out.println(i);
    }
}

1.3. 使用匿名内部类或者Lambda表达式实现创建线程

public class demo_lambda {
 // 匿名内部类实现创建线程
    public static void main(String[] args) {
        new Thread(new Thread()
        {
            public void run()
            {
                System.out.println("启动1"+Thread.currentThread().getName()); //获得当前线程名
            }
        }).start();
  //Lambda表达式：创建线程
        new Thread(()->
        {
            System.out.println("启动2"+Thread.currentThread().getName());
        }).start();
    }
}

测试结果

在这里插入图片描述

1.4 通过线程池创建（推荐）

前言：引用地址

ps:篇幅有限，没法完整介绍。

1.4.1.ExecutorsService同Thread 的区别

我们之前使用线程的时候都是使用new Thread来进行线程的创建，但是这样会有一些问题。如：

a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。

而我们今天来学习和掌握另外一个新的技能，特别像一个线程池的一个接口类ExecutorService，下面我们来了解下java中Executors的线程池

1.4.2.Java通过Executors提供四种线程池，分别为：

1.newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2.newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3.newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
4.newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

1.4.3.使用ExecutorService 创建

package com.basic.test;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadTest implements Runnable
{
    public static void main(String[] args) throws InterruptedException {
        //创建一个定长为3的线程池
        ExecutorService service = Executors.newFixedThreadPool(3);
        //提交二个任务
        service.submit(new ThreadTest());
        service.submit(new ThreadTest());
        //关闭线程
        service.shutdown();

    }

    //要执行的任务
    @Override
    public void run() {
        for (int i=0;i<10;i++)
            System.out.println(Thread.currentThread().getName()+"--->"+i);

    }
}

执行结果

pool-1-thread-2--->0
pool-1-thread-2--->1
pool-1-thread-2--->2
pool-1-thread-1--->0
pool-1-thread-1--->1
pool-1-thread-1--->2
pool-1-thread-2--->3
pool-1-thread-2--->4
pool-1-thread-2--->5
pool-1-thread-2--->6
pool-1-thread-1--->3
pool-1-thread-2--->7
pool-1-thread-1--->4
pool-1-thread-2--->8
pool-1-thread-1--->5
pool-1-thread-1--->6
pool-1-thread-1--->7
pool-1-thread-1--->8
pool-1-thread-1--->9
pool-1-thread-2--->9

个人认为ExecutorService说的比较好的博客链接

save_TT

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java多线程基础-学习之路(1)

Java多线程基础(1)1.多线程的概念 1.1.进程和线程的区别：1.本质：每一个进程都有一套自己的一整套变量，而进程则共享数据。可以把进程看成火车，线程看成车厢，一个进程可以包含多个线程，共享变量使线程间的通信更有效，容易，同时线程与进程比，线程更轻量级，创建，撤销比启动进程开销小的多。2.使用线程是为了提高系统的执行效率，减少处理机的空转时间和调度切换的时间，以及便于系统管理。 1.2线程简介线程的三个基本状态：执行（Running），就绪（Runnable
复制链接

扫一扫