java多线程之线程基础

最新推荐文章于 2024-09-07 21:56:33 发布

ruan_luqingnian

最新推荐文章于 2024-09-07 21:56:33 发布

阅读量601

点赞数 1

分类专栏： Java多线程文章标签：多线程 java 多进程操作系统并发编程

本文链接：https://blog.csdn.net/ruan_luqingnian/article/details/115973841

版权

Java多线程专栏收录该内容

11 篇文章 0 订阅

订阅专栏

线程基础

进程与线程的区别

进程

是系统进行分配和管理资源的基本单位

线程

进程的一个执行单元，是进程内调度的实体、是CPU调度和分派的基本单位，是比进程更小的独立运行的基本单位。线程也被称为轻量级进程,线程是程序执行的最小单位。

二者关系

一个程序至少一个进程，一个进程至少一个线程。
进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。
而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。
线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式进行。
如何处理好同步与互斥是编写多线程程序的难点。
多进程程序更健壮，进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，
而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，所以可能一个线程出现问题，进而导致整个程序出现问题

线程的状态及其相互转换

现成的几种状态

初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。
阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。
等待(WAITING)：Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
超时等待(TIME_WAITING)：Object.wait(long)、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil，该状态不同于WAITING，它可以在指定的时间内自行返回。
终止(TERMINATED)：表示该线程已经执行完毕。

相互转化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QJMw6Rme-1619004559464)(C:\Users\阮相歌\AppData\Roaming\Typora\typora-user-images\image-20210421124450904.png)]

创建线程的方式

1.继承Thread，并重写父类的run方法

继承Thread，并重写父类的run方法

package 多线程;

/**
 * 创建线程方法一
 * 继承Thread
 * 1.继承Thread
 * 2.重写父类的run方法
 */
public class ThreadDemo extends Thread {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.setName("继承Thread方式创建线程");
        threadDemo.start();
    }
}

2.实现Runable接口，并实现run方法

package 多线程;

/**
 * 通过实现runnable接口创建线程
 * 重写run方法
 */
public class RunnableDemo implements Runnable  {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableDemo());
        thread.setName("实现Runnable接口方式创建线程");
        thread.start();
    }
}

实际开发中，选第此种—java只允许单继承
增加程序的健壮性，代码可以共享，代码跟数据独立

3.使用匿名内部类

package 多线程;
/**
*匿名内部类方式创建线程
*/
public class MyThread {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        thread.start();
    }
}

4.Lambda表达式

package 多线程;

/**
 * 使用lambda表达式创建
 */
public class MyLambda {
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName());
        }).start();
    }
}

线程池创建

package 多线程;

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

/**
 * 线程池创建
 */
public class MyThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(()->{
            System.out.println(Thread.currentThread().getName());
        });
    }


}

线程的挂起和恢复

什么是挂起线程

线程的挂起操作实质上就是使线程进入“非可执行”状态下，在这个状态下CPU不会分给线程时间片，进入这个状态可以用来暂停一个线程的运行。
在线程挂起后，可以通过重新唤醒线程来使之恢复运行

为什么要挂起线程

cpu分配的时间片非常短、同时也非常珍贵。避免资源的浪费。

如何挂起线程

被废弃的方法

thread.suspend()
- 该方法不会释放线程所占用的资源。如果使用该方法将某个线程挂起，则可能会使其他等待资源的线程死锁
thread.resume()
- 方法本身并无问题，但是不能独立于suspend()方法存在

可以使用的方法

wait() 暂停执行、放弃已经获得的锁、进入等待状态
notify() 随机唤醒一个在等待锁的线程
notifyAll() 唤醒所有在等待锁的线程，自行抢占cpu资源

什么时候时候使用挂起线程

我等的船还不来(等待某些未就绪的资源)，我等的人还不明白。直到notify方法被调用

线程的中断操作

stop() 废弃方法

开发中不要使用。因为一调用，线程就立刻停止，此时有可能引发相应的线程安全性问题

package 多线程;

public class UnsafeWithStop extends Thread {

    private int i = 0;
    private int j = 0;

    @Override
    public void run() {
        i++;
        try {
            Thread.sleep(2000l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        j++;
    }
    public void printf(){
        System.out.println("i的值是="+i);
        System.out.println("j的值是="+j);
    }

    public static void main(String[] args) throws InterruptedException {
        UnsafeWithStop unsafeWithStop = new UnsafeWithStop();
        unsafeWithStop.start();
        Thread.sleep(1000l);
        unsafeWithStop.stop();
        unsafeWithStop.printf();
    }
}

Thread.interrupt方法

package 多线程;

public class Demo implements Runnable {
    //重写run方法创建线程
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()){
            System.out.println(Thread.currentThread().getName());

        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Demo());
        thread.start();
        Thread.sleep(1000l);
        thread.interrupt();
    }
}

自行定义一个标志，用来判断是否继续执行

package 多线程;

public class MyInterruptDemo implements Runnable {
    private static volatile boolean FLAG = true;
    @Override
    public void run() {
        while (FLAG){
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new MyInterruptDemo());
        Thread.sleep(2000l);
        thread.start();
        FLAG = false;
    }
}

线程的优先级

线程的优先级告诉程序该线程的重要程度有多大。如果有大量线程都被堵塞，都在等候运行，程序会尽可能地先运行优先级的那个线程。但是，这并不表示优先级较低的线程不会运行。若线程的优先级较低，只不过表示它被准许运行的机会小一些而已。
线程的优先级设置可以为1-10的任一数值，Thread类中定义了三个线程优先级，分别是：
- MIN_PRIORITY（1）、NORM_PRIORITY（5）、MAX_PRIORITY（10），一般情况下推荐使用这几个常量，不要自行设置数值。
不同平台，对线程的优先级的支持不同。编程的时候，不要过度依赖线程优先级，如果你的程序运行是否正确取决于你设置的优先级是否按所设置的优先级运行，那这样的程序不正确
任务
- 快速处理：设置高的优先级
- 慢慢处理：设置低的优先级

package 多线程;

public class PriorityDemo {

    public static void main(String[] args) {
        Thread thread1 = new Thread(()->{
            while (true){
                System.out.println(Thread.currentThread().getName());
            }

        },"线程1");
        Thread thread2 = new Thread(()->{
            while (true){
                System.out.println(Thread.currentThread().getName());
            }
        },"线程2");
        //设置线程优先级
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }
}

线程守护

线程的分类

用户线程、守护线程
- 守护线程：任何一个守护线程都是整个程序中所有用户线程的守护者，只要有活着的用户线程，守护线程就活着。当JVM实例中最后一个非守护线程结束时，也随JVM一起退出

作用

守护线程的用处：jvm垃圾清理线程

建议

尽量少使用守护线程，因其不可控
不要在守护线程里去进行读写操作、执行计算逻辑

package 多线程;

public class DaemonDemo {

    public static void main(String[] args) {
        Thread thread1 = new Thread(()->{
            while (true){
                System.out.println(Thread.currentThread().getName());
            }

        },"线程1");
        Thread thread2 = new Thread(()->{
            while (true){
                System.out.println(Thread.currentThread().getName());
            }
        },"线程2");
        //设置线程守护
        thread1.setDaemon(true);
        thread1.start();
        thread2.start();
    }
}

ruan_luqingnian

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java多线程之线程基础

线程基础线程基础进程与线程的区别进程线程二者关系线程的状态及其相互转换现成的几种状态相互转化创建线程的方式1.继承Thread，并重写父类的run方法2.实现Runable接口，并实现run方法3.使用匿名内部类4.Lambda表达式线程池创建线程的挂起和恢复什么是挂起线程为什么要挂起线程如何挂起线程被废弃的方法可以使用的方法什么时候时候使用挂起线程线程的中断操作stop() 废弃方法Thread.interrupt方法自行定义一个标志，用来判断是否继续执行线程的优先级线程守护线程的分类作用建议线程基础
复制链接

扫一扫

专栏目录