线程Thread
相关概念
1.程序:安装的软件,例如QQ,微信,IDEA等.
2.进程:在运行的程序.
3.线程:进程中多个同时在执行的任务,如360杀毒软件同时执行病毒查杀,垃圾清理,加速等任务.
<1>并行:通过一时间同时发生.
<2>并发:微观上的交替运行–同一时间段内发生,很短的时间段,看起来是同时发生的
4.多线程的特点–并发.
线程的构造方法
1.new 自定义线程类 ();–自定义类的构造方法,随意
2.new Thread();
3.new Thread(String);–String–>指定的线程名(线程名也可以不指定,有默认名称)
4.new Thread(Runnable);–Runnable–>线程任务
5.new Thread(Runnable,String);
线程常用的API
1.static Thread currentThread();–获得当前正在执行的线程对象.
2.String getName();–获得线程对象的名字,线程在创建时就可以指定名字,也可以使用系统默认的名称.
3.int getPriority();–返回此线程的优先级(1~10).
void setPriority();–设置此线程的优先级.
优先级1~10,数越大优先级越高,CPU分配给时间片的几率越大
4.boolean isDaemon();–测试这个线程是否是守护线程
void setDaemon(boolean);–设置这个线程是否是守护线程
(默认所有的线程都不是守护线程)
5.static void sleep(long);–制造延迟,让线程暂停一下
6.void join();–等待调用这个方法的线程结束,再继续后续代码.(会有一个异常,try-catch处理一下)
7.static void yield();–主动放弃CPU的时间片,不用等到时间片过期就回到了Runnable可执行状态
守护线程
当所有的前台线程(不是守护线程的线程)结束,那么守护线程也结束.GC(垃圾回收)就是守护线程.
开启多线程任务—创建多个线程对象Thread
创建多个线程对象 Thread，并发的，有先后顺序
注意: 不是哪个线程先start, 就先执行哪个线程,线程的执行顺序, 是不固定的
方法1:
自定义一个线程类,继承Thread
重写run方法,run方法里写要执行的任务
创建线程对象
开启线程 start();
方法2:
自定义一个线程类,实现Runnable接口
重写run方法,run方法里写要执行的任务
创建任务对象
通过任务对象,创建线程对象
开启线程 start();
方法3:
匿名内部类实现多线程—以上两种方式的匿名内部类改写
(匿名内部类的本质就是继承一个类,或实现一个接口)
//1.1自定义线程类,继承Thread--一个类只能,有一个父类,只能继承一个类--这种方法只能是线程类--受限制了
public class Thread1 extends Thread {
//1.2重写run方法 线程要执行的任务
public void run() {
//线程要执行的任务 比如:
for (int i = 0; i < 10; i++) {
System.out.println("多线程执行了:"+i);
}
}
public class DemoThread {
public static void main(String[] args) {
//开启多线程任务
//1.3创建线程对象
Thread1 t=new Thread1();
//1.4开启线程
//t.run();--错误--就是单纯的方法调用了
t.start();//---正确 一旦start开始就创建了线程t,此时主方法里有两个线程--main和t--多线程特点:并发
---------------------------------------------------------------------------------------------------
public class DemoThread2 {
public static void main(String[] args) {
//开启多线程任务
//2.2创建任务对象
Thread2 task=new Thread2();
//2.3通过任务对象,构造线程对象
Thread th=new Thread(task);
//2.4开启线程
//t.run();--错误--就是单纯的方法调用了
th.start();//---正确 一旦start开始就创建了线程t,此时主方法里有两个线程--main和t--多线程特点:并发
//主方法里加入循环,目的时打印出main的线程任务,同t的比较
for(int i=0;i<10;i++) {
System.out.println("main:" + i);
}
}
}
public static void main(String[] args) {
Thread t = new Thread() {
public void run() {
Thread t = Thread.currentThread();//获得当前正在执行的线程对象
for (int i = 0; i < 10; i++) {
System.out.println(t.getName() + ": " + i);
}
}
};
t.start();
Runnable run = new Runnable() {
public void run() {
Thread t = Thread.currentThread();
for (int i = 0; i < 10; i++) {
System.out.println(t.getName() + ": " + i);
}
}
};
Thread t1 = new Thread(run);
t1.start();
线程同步的安全问题
线程同步:多个线程,共享资源–会抢夺资源
解决线程同步的安全问题—加锁
1.synchronized-同步锁,同一时间只能同时被一个线程拥有,当线程执行完这个方法,才会将锁释放归还. 使用原则:将尽量少的代码加锁
<1>加到方法上—public后,同步方法锁 - 效率比较低
锁普通方法 – 就是锁this对象
锁静态方法 – 锁的是类.class(类的字节码)对象
<2>借助一个对象 synchronized(对象){ } — 可以是任意对象,只需要确保多个同步的线程对象唯一就可以了,通常使用this对象
2.Lock(I)锁:接口,不能直接new,new Lock(I)的实现类,如ReentrantLock();可以锁方法,也可以锁代码块(本身自己会做判断,不需要多做考虑)
实现类: ReentrantLock lock = new ReentrantLock();
加锁: 锁对象.lock();
解锁: 锁对象.unlock();
// 模拟当前票的余量
public class Ticket {
// 票的余量是100张
public int count = 100;
// 创建锁对象
private ReentrantLock lock = new ReentrantLock();
public void saleTicket() {
// 加上锁
lock.lock();
if (count == 0) {
throw new RuntimeException("票卖完了!");
}
System.out.println(Thread.currentThread().getName() + "正在出票: " + count);
count--;
// 打开锁
lock.unlock();
System.out.println(Thread.currentThread().getName() + "卖完一张票");
}
线程的状态
Blocked锁阻塞,Waiting无限等待,Timed Waiting即使等待 — 统称为阻塞状态.join()也会造成阻塞,是让别的线程阻塞.
线程的通信
1.线程的通信:
两个线程有共享数据,线程之间有动作交互.两个线程会互相等待/唤醒(只能唤醒对方).不同于线程同步的抢夺资源,线程通信有组织有纪律,要么你来要么我来,不会抢夺资源.
2.线程的唤醒和等待要在同一个锁里
<1>wait(); — 等待,为保证等待的状态只被唤醒而不被打断,要配合synchronized()同步锁来使用(会出现一个异常)
<2>notify(): — 唤醒,也加锁synchronized()
线程池
相关
1.池 — 节约内存
2.之前写的线程执行后就进入死亡状态了,本身就比价消耗时间和内存,效率不高 — 由此产生了线程池
3.线程池里面放了很多线程对象供用户使用,使用完之后不是进入死亡状态,而是又返回到线程池,重复利用.节约内存,提高效率.
JDK中提供的4种线程池
4种线程池都对应一个线程池接口:java.util.concurrent.ExecutorService
1.newCachedThreadPool(): 创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程。
2.newFixedThreadPool(int nThreads): 创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。— 常用
3.newScheduledThreadPool(int corePoolSize): 创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。— 了解
4.newSingleThreadExecutor(): 创建一个使用从无界队列运行的单个工作线程的执行程序。— 了解
线程池执行任务的API
1.submit(Runnable/Callable)-提交指定的任务去执行并且返回Future对象
有返回值Future,给Runnable返回null,给Callable返回call()方法的返回值
Future f=pool.submit(run);–>将线程任务交给线程池
Date date=f.get();–>返回run()方法第一次执行结束的时间
pool.shoutdown();–>手动关闭线程池.会自动将里面的线程对象销毁
注:如果没有关闭线程池,线程对象依然在,程序就不会结束
2.execute(Runnable)-没有返回值void
Callable
Callable(线程任务, 只能用在线程池) -> Runnable
new Thread(new Runnable(){});
new Thread(new Callable(){}); // — 错误的!!
Callable对象只能在 : Future f = pool.submit(Callable);
f.get() -> 得到call方法的返回值
可能会遇到阻塞
f.get(long, TimeUnit.xx) -> 超时继续
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 创建一个固定线程数量的线程池, 创建好线程池的时候, 就已经有了三个线程对象
ExecutorService pool = Executors.newFixedThreadPool(3);
// 通过线程任务, 来获得线程对象并且直接开始线程
Callable run = new Callable<Date>(){
@Override
public Date call() throws Exception{
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
Thread.sleep(10000);
return new Date();
}
};
// 将线程任务交给线程池 -- 线程对象可以反复使用
Future<Date> f = pool.submit(run);
Date d = f.get(); // 得到Callable里面call方法的返回值
System.out.println(d);
/*try {
Date date = f.get(3, TimeUnit.SECONDS);
System.out.println(date);
} catch (TimeoutException e) {
System.out.println("结果超时了");
}*/
System.out.println("主线程继续");
// 如果没有关闭线程池, 线程对象依然在, 程序就不会结束
// 手动关闭线程池 - 会自动将里面的线程对象销毁
pool.shutdown();
}
pool-1-thread-1: 0
pool-1-thread-1: 1
pool-1-thread-1: 2
pool-1-thread-1: 3
pool-1-thread-1: 4
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
Thu Jul 30 20:26:34 CST 2020
主线程继续
线程池的好处
**池化技术应用：线程池、数据库连接池、http连接池等等。
池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。
线程池提供了一种限制、管理资源的策略。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。
使用线程池的好处：
1.降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
2.提高响应速度：当任务到达时，可以不需要等待线程创建就能立即执行。
3.提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，监控和调优。
1299
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
