线程基础
创建线程的方式:
1.继承Thread类
什么是run方法:run方法就是线程要执行的任务方法;
重写run方法:
public class MyThread extends Thread{
@Override
public void run() {
//这里的代码 就是一条新的执行路径
//这个执行路径的触发方式,不是调用run方法。而是通过调用thread对象的start来启动任务
for (int i=0;i<10;i++){
System.out.println("线程可以吃吗?"+i);
}
}
}
开启线程:
public class Demo {
public static void main(String[] args) {
MyThread m=new MyThread();
m.start();//m线程开启
for (int i=0;i<10;i++){
System.out.println("线程当然可以吃!"+i);
}
}
}
运行结果:
线程能吃吗?0
线程当然可以吃!0
线程能吃吗?1
线程当然可以吃!1
线程能吃吗?2
线程当然可以吃!2
线程能吃吗?3
线程当然可以吃!3
2.实现Runnable接口
Runnnable接口是用于给线程执行的任务;
- 实现Runnnable接口与继承Thread类相比的优势是:
- 实现runnable接口是通过创建任务,然后给线程分配的方式来实现的多线程。更适合多个线程同时执行相同任务的情况。
- 可以避免单继承所带来的局限性
- 任务与线程本身是分离的,提高了程序的健壮性
- 后续学习的线程技术,只接受runnable类型的任务,而不接受Thread类型的线程。
实现方式:
public class MyRunnable implements Runnable{
@Override
public void run() {
//线程的任务
for (int i=0;i<10;i++){
System.out.println("线程能吃吗?"+i);
}
}
}
public class Demo {
public static void main(String[] args) {
//实现runnable
//1.创建一个任务对象
MyRunnable r=new MyRunnable();
//2.创建一个线程, 并为其分配一个任务
Thread t=new Thread(r);
//3.执行这个线程
t.start();
for (int i=0;i<10;i++){
System.out.println("疑似地上霜"+i);
}
}
}
运行结果:
线程当然可以吃!5
线程能吃吗?6
线程当然可以吃!6
线程能吃吗?7
线程能吃吗?8
线程能吃吗?9
线程当然可以吃!7
可见线程执行任务是抢占式的,不保证顺序。
3.实现callable接口
Runnable 与 Callable的相同点:
1.都是接口
2.都可以编写多线程程序
3.都采用Thread.start()启动线程
Runnable 与 Callable的不同点:
1.Runnable没有返回值;Callable可以返回执行结果
2.Callable接口的call()允许抛出异常;Runnable的run()不能抛出
实现方式:
public class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("我是callable!");
return null;
}
}
public class CallableDemo {
public static void main(String[] args) {
MyCallable c=new MyCallable();
FutureTask <String> f=new FutureTask<>(c);
new Thread(f).start();
}
}
运行结果:
我是callable!
线程的休眠:
public class ThreadSleepDemo {
public static void main(String[] args) throws InterruptedException {
//线程的休眠 sleep
for (int i=0;i<10;i++){
System.out.println(i);
Thread.sleep(1000);//睡眠一秒,单位是毫秒
}
}
}
线程的阻塞与死亡
线程阻塞是什么?
是所有消耗时间的操作,比如接收用户输入,或者文件读取;
线程的结束:
一个线程是一个独立的执行路径,他是否结束,应该由线程自身决定
public class Demo3 {
public static void main(String[] args) {
Thread t1= new Thread(new MyRunnable());
t1.start();
for (int i=1;i<=10;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
//Thread.currentThread().getName()方法用于获取当前线程名字
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
t1.interrupt(); //给线程t1添加中断标记,只是告知线程应该死亡,并不决定死亡,具体操作在catch块
}
static class MyRunnable implements Runnable{
@Override
public void run() {
for (int i=1;i<=100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
return;//结束线程
}
}
}
}
}
运行结果:
main:1
Thread-0:1
Thread-0:2
main:2
main:3
Thread-0:3
main:4
Thread-0:4
Thread-0:5
main:5
main:6
Thread-0:6
Thread-0:7
main:7
main:8
Thread-0:8
main:9
Thread-0:9
Thread-0:10
main:10
Thread-0:11
守护线程:
线程:分为守护线程和用户线程
用户线程:当一个进程不包含任何用户线程时,进行结束。
守护线程:用于守护用户线程线程,当最后一个用户线程结束时 ,所有守护线程自动死亡
public class Demo4 {
public static void main(String[] args) {
Thread t1= new Thread(new Demo3.MyRunnable());
t1.setDaemon(true);//设置t1为守护线程
t1.start();
for (int i=1;i<=10;i++){//主线程循环10次
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class MyRunnable implements Runnable{
@Override
public void run() {
for (int i=1;i<=100;i++){//守护线程循环100次
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
运行结果:
main:1
Thread-0:1
Thread-0:2
main:2
Thread-0:3
main:3
Thread-0:4
main:4
main:5
Thread-0:5
Thread-0:6
main:6
main:7
Thread-0:7
Thread-0:8
main:8
main:9
Thread-0:9
Thread-0:10
main:10
Thread-0:11
结果表示:当主线程死亡时,守护线程不管是否执行完毕,都随主线程一起死亡
线程不安全问题:
因为线程是抢占执行的,当 cpu 执行一个线程过程时,调度器可能调走CPU,去执行另一个线程,此线程的操作可能还没有结束,这个时候多个线程尝试修改同一个变量会很容易出现不同步问题。
线程不安全解决方式:
1.同步代码块(隐式锁)
/*
* 线程同步synchronized
* */
public class ThreadSafe {
//格式:synchronized(锁对象(任何对象)){}
public static void main(String[] args) {
//线程不安全
Runnable r=new Ticket();
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
}
static class Ticket implements Runnable{
//票数
private int count=10;
private Object o=new Object();
@Override
public void run() {
while (true){
synchronized (o){
if (count>0){
//卖票
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"出票成功,余票:"+count);
}else
break;
}
}
}
}
}
运行结果:
正在准备卖票
Thread-0出票成功,余票:9
正在准备卖票
Thread-0出票成功,余票:8
正在准备卖票
Thread-0出票成功,余票:7
正在准备卖票
Thread-0出票成功,余票:6
正在准备卖票
Thread-0出票成功,余票:5
正在准备卖票
Thread-2出票成功,余票:4
正在准备卖票
Thread-2出票成功,余票:3
正在准备卖票
Thread-2出票成功,余票:2
正在准备卖票
Thread-2出票成功,余票:1
正在准备卖票
Thread-2出票成功,余票:0
2.同步方法(隐式锁)
public class SafeMethod {
public static void main(String[] args) {
//线程不安全
Runnable r=new ThreadSafe.Ticket();//new一次一个对象,多次new锁不了
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
}
static class Ticket implements Runnable{
//票数
private int count=10;
@Override
public void run() {
while (true){
boolean flag=sale();
if (!flag){
break;
}
}
}
public synchronized boolean sale(){
if (count>0){
//卖票
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"出票成功,余票:"+count);
return true;
}
return false;
}
}
}
运行结果:
正在准备卖票
Thread-0出票成功,余票:9
正在准备卖票
Thread-0出票成功,余票:8
正在准备卖票
Thread-0出票成功,余票:7
正在准备卖票
Thread-0出票成功,余票:6
正在准备卖票
Thread-0出票成功,余票:5
正在准备卖票
Thread-0出票成功,余票:4
正在准备卖票
Thread-0出票成功,余票:3
正在准备卖票
Thread-0出票成功,余票:2
正在准备卖票
Thread-0出票成功,余票:1
正在准备卖票
Thread-0出票成功,余票:0
3.显式锁(更体现控制锁的概念)
public class LockBig {
public static void main(String[] args) {
Runnable r=new Ticket();//new一次一个对象,多次new锁不了
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
}
static class Ticket implements Runnable{
//票数
private int count=10;
//显式锁
/*private Lock l=new ReentrantLock();*///默认不公平锁抢占
private Lock l=new ReentrantLock(true);//true表示公平锁,先来先得
@Override
public void run() {
while (true){
l.lock();
if (count>0){
//卖票
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"出票成功,余票:"+count);
}else
break;
l.unlock();
}
}
}
}
线程池
线程池的作用:
1.降低资源消耗;
2.提高响应速度;
3.提高线程的可管理性;
1.缓存线程池:
- 缓存线程池:
- (长度无限制)
- 任务加入后执行流程
1:判断线程池是否存在空闲线程
2:存在则使用
3:不存在,则创建线程,并放入线程池,然后使用
public class Demo1 {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();//创建缓存线程池
service.execute(new Runnable() { //线程池执行任务
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程池能游泳吗?");
}
});
service.execute(new Runnable() { //线程池执行任务
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程池能游泳吗?");
}
});
service.execute(new Runnable() { //线程池执行任务
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程池能游泳吗?");
}
});
try {
Thread.sleep(1000);//休眠一秒,测试线程是否能复用
} catch (InterruptedException e) {
e.printStackTrace();
}
service.execute(new Runnable() { //线程池执行任务
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程池能游泳吗?");
}
});
}
}
运行结果:
pool-1-thread-1线程池能游泳吗?
pool-1-thread-2线程池能游泳吗?
pool-1-thread-3线程池能游泳吗?
pool-1-thread-3线程池能游泳吗?
2.定长线程池:
- 定长线程池:
- (长度是指定的数值)
- 任务加入后执行流程:
1:判断线程池是否存在空闲线程
2:存在则使用
3.不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池,然后使用
4.不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
public class Demo2 {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程池能游泳吗?");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程池能游泳吗?");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"听人说可以!");
}
});
}
}
执行结果:(第三行3秒后出现)
pool-1-thread-1线程池能游泳吗?
pool-1-thread-2线程池能游泳吗?
pool-1-thread-2听人说可以!
3.单线程线程池:
* 单线程线程池.
* 执行流程:
* 1.判断线程池的那个线程 是否空闲
* 2.空闲则使用
* 3.不空闲则等待 池中的单个线程空闲后 使用
public class Demo3 {
public static void main(String[] args) {
ExecutorService service= Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程池能游泳吗?");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程池能游泳吗?");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程池能游泳吗?");
}
});
}
}
执行结果:
pool-1-thread-1线程池能游泳吗?
pool-1-thread-1线程池能游泳吗?
pool-1-thread-1线程池能游泳吗?
4.周期性任务线程池:
- 周期性任务线程池
1:判断线程池是否存在空闲线程
2:存在则使用
3.不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池,然后使用
4.不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
周期性任务执行时:
定时执行,当某个时机触发时,自动执行某任务。
定时执行
* 参数1. 定时执行的任务
* 参数2.时长数字
* 参数3.时长数字的时间单位TimeUnit的常量指定
public class Demo4 {
public static void main(String[] args) {
ScheduledExecutorService service= Executors.newScheduledThreadPool(2);
service.schedule(new Runnable() {
@Override
public void run() {
System.out.println("线程池能游泳吗?");
}
},5, TimeUnit.SECONDS);
}
}
五秒后执行结果:
线程池能游泳吗?
周期性执行任务
* 周期性执行任务
* 参数1.任务
* 参数2.延迟时长数字(第一次执行在什么时间之后)
* 参数3.周期时长数字(每隔多久执行一次)
* 参数4.时长数字单位
public class Demo4 {
public static void main(String[] args) {
ScheduledExecutorService service= Executors.newScheduledThreadPool(2);
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("好像不可以吧!");
}
},5,1,TimeUnit.SECONDS);
}
}
执行结果:(先等五秒开始执行,执行第一条后,每隔一秒执行一次)
好像不可以吧!
好像不可以吧!
好像不可以吧!
好像不可以吧!
好像不可以吧!
好像不可以吧!