Java线程

最新推荐文章于 2024-08-18 21:36:31 发布

Silver1231

最新推荐文章于 2024-08-18 21:36:31 发布

阅读量137

点赞数

文章标签： java 多线程

本文链接：https://blog.csdn.net/Silver1231/article/details/113917259

版权

线程与进程

进程

一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

是进程的一个执行路径，线程之间可以自由切换，一个进程最少有一个线程

线程实际上是在进程基础上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分为若干个线程

线程调度

分时调度

所有线程轮流使用CPU使用权，平均分配每个线程占用CPU的时间

抢占式调度

让优先级高的线程先试用CPU，如果线程的优先级相同，则随机选择一个，java使用的是抢占式调度

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

同步与异步

同步安全，异步不安全

同步

排队执行，效率低但是安全

异步

同步执行，效率高但是数据不安全

并发与并行

并发

指两个或多个时间在同一个时间段内发生

并行

指两个或多个时间在同一时刻发生

继承Thread

每个线程都有自己的占空间，共用一份内存

//调用MyThread对象的start方法执行run()中的内容
public class MyThread extends Thread{
    @Override
    public void run(){
        
    }
}

//匿名内部类的写法
public static void main(String[] args) {
    new Thread() {
        @Override
        public void run() {
            
        }
    }.start();
}

实现Runnable

//任务类
public class myRunnable implememts Runnable{
    @Override
    public void run() {
        
    }
}

public static void main(String[] args) {
	//实现Runnable
    //1.创建任务对象
    MyRunnable r = new MyRunnable();
    //2.创建一个线程，并为其分配任务
    Thread t = new Thread(r);
    //3.执行这个线程
    t.start();
}

实现Runnable与继承Thread相比的优势：

1.通过创建任务，然后给线程分配的方式来实现多线程，更加适合多个线程同时执行相同任务的情况

2.可以避免单继承带来的局限性

3.任务与线程本身是分离的

4.后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程

Thread

Constructor

Thread()

Thread(Runnable target)

Thread(Runnable target, String name)

Thread(String name)

字段

static int MAX_PRIORITY 线程可以拥有的最大优先级 10

static int MIN_PRIORITY 线程可以拥有的最低优先级 1

static int NORM_PRIORITY 分配给线程的默认优先级 5

public static int activeCount()

返回当前线程thread group及其子组中活动线程数的估计值

public final void checkAccess()

确定当前运行的线程是否具有修改此线程的权限

异常：SecurityException 不允许当前线程修改此线程

public static Thread currentThread()

返回当前正在执行的线程对象

public long getID()

返回此线程的标识符

public final String getName()

返回此线程名称

public final int getPriority()

返回此线程的优先级

public final void setName(String name)

将此线程的名称修改为name

异常：SecurityException 不允许当前线程修改此线程

public final void setPriority(int newPriority)

更改优先级

异常：SecurityException 不允许当前线程修改此线程

IllegalArgumentException 新的优先级超出范围

public static void sleep(long millis) throws InterruptedException

当前线程休眠指定毫秒数

异常：IllegalArgumentException (millis < 0)

InterruptedException 有任何线程中断了当前线程

public static void sleep(long millis, int nanos) throws InterruptedException

当前线程休眠指定的毫秒数加上纳秒数

异常：IllegalArgumentException (millis < 0 || nanos < 0)

InterruptedException 有任何线程中断了当前线程

public void start()

public void interrupt()

中断线程

public static boolean interrupted()

中断返回true，没有中断返回false

线程的中断

线程是否应该接受应该由线程本身决定

直接用stop方法是不合适的

可以用interrupt方法给线程标记，然后在InterruptedException中决定是否结束进程

守护线程

线程分为守护线程和用户线程

用户线程：当一个进程不包含任何存活的用户线程时，进程结束

守护线程：守护用户线程，当最后一个用户线程结束时，所有守护线程自动死亡

方法：public final void setDaemon(boolean on)

线程安全

1.同步代码块

格式：synchronized(锁对象) {

}

2.同步方法

synchronized修饰方法

3.显式锁

private Lock l = new ReentrantLock();

	l.lock();
	...
	l.unlock();

公平锁与非公平锁

公平锁：先到先得

实现：private Lock l = new ReentrantLock(true); 默认是false

非公平锁：谁抢到谁先，上述三种都是非公平锁

线程死锁

例：两个线程中的方法互相调用了被锁的方法

线程的六种状态

NEW 尚未启动

RUNNABLE 在JVM中执行的线程

BLOCKED 被阻塞等待监视器锁定

WAITING 无期限等待另一个线程执行特定操作

TIMED_WAITING 指定时间等待

TERMINATED 结束的线程

带返回值的线程Callable

使用步骤

1.编写类实现Callable接口，实现call方法

2.创建FutureTask对象，传入第一步编写的Callable类对象

3.通过Thread启动线程（传入Futuretask对象）

线程池

是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作

缓存线程池

长度无限制

执行流程：

1.判断线程池是否存在空闲线程

2.存在即使用

3.不存在，则创建线程并放入线程池，然后使用

ExecutorService service = Executors.newCachedThreadPool();
//指挥线程池执行新的任务
service.execute(new Runnable() {
    @Override
    public void run() {
        
    }
});

定长线程池

长度是指定的数值(在newFixedThreadPool()的括号中)

任务加入后的执行流程

1.判断线程池是否存在空闲

2.存在则使用

3.不存在空闲线程，且在线程池未满的情况下，则创建线程并放入线程池，然后使用

4.不存在空闲线程，且在线程池已满的情况下，则等待线程池存在空闲线程

ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
    @Override
    public void run() {
        
    }
});
service.excute(new Runnable() {
    @Override
    public void run() {
        
    }
});

单线程线程池

执行流程

1.判断线程池的哪个线程是否空闲

2.空闲则使用

3.不空闲则等待，池中的单个线程空闲后再使用

ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
    @Override
    public void run() {
        
    }
});

周期定长线程池

执行流程

1.判断线程池是否存在空闲线程

2.存在则使用

3.不存在空闲线程，且在线程池未满的情况下，则创建线程并放入线程池，然后使用

4.不存在空闲线程，且在线程池已满的情况下，则等待线程池存在空闲线程

ScheduledExecutorService service = Executors.newScheduledThread(2);
//1.定时执行一次
//参数1. 定时执行的任务
//参数2. 时长数字
//参数3. 时长数字的时间单位，TimeUnit的常量指定
service.schedule(new Runnable() {
    @Override
    public void run() {
        
    }
}, 5, TimeUnit.SECONDS);

//周期执行任务
//参数1. 任务
//参数2. 延迟时长数字(第一次执行在什么时间以后)
//参数3. 周期时长数字(每隔多久执行一次)
//参数4. 时长数字的单位
ScheduledExecutorService service = Executors.newScheduledThread(2);
service.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        
    }
}, 5, 1, TimeUnit.SECONDS);

Silver1231

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java线程

线程与进程进程一个内存中运行的应用程序，每个进程都有一个独立的内存空间线程是进程的一个执行路径，线程之间可以自由切换，一个进程最少有一个线程线程实际上是在进程基础上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分为若干个线程线程调度分时调度所有线程轮流使用CPU使用权，平均分配每个线程占用CPU的时间抢占式调度让优先级高的线程先试用CPU，如果线程的优先级相同，则随机选择一个，java使用的是抢占式调度CPU使用抢占式调度模式在多个线程间进行着高速的切换。
复制链接

扫一扫