Java中多线程、同步、runnable、callable接口

最新推荐文章于 2022-06-28 18:31:46 发布

Z次方-Y

最新推荐文章于 2022-06-28 18:31:46 发布

阅读量448

点赞数

分类专栏： Java攻城狮文章标签：多线程

本文链接：https://blog.csdn.net/lyz2017/article/details/82693472

版权

Java攻城狮专栏收录该内容

16 篇文章 0 订阅

订阅专栏

一、多线程

1 多线程第一种方式的实现步骤（继承Thread类）

1、定义类重写Thread类；

2、重写里面的run方法，在run方法中定义线程要执行的任务。

3、创建Thread子类对象

4. 调用子类对象的start方法，启动线程。

public class Demo01Thread {

public static void main(String[] args) {

System.out.println("main...start");

//创建Thread子类对象

MyThread mt = new MyThread();

//调用start方法启动线程

mt.start();

//打印100次HelloWorld

for(int i = 1; i <= 100; i++) {

System.out.println("HelloWorld:" + i);

}

System.out.println("main....end");

}

2、 Thread中的常见方法

构造方法：

public Thread(String name)：传递一个线程的名字。

成员方法：

void setName(String name)：给线程设置名字。

String getName()：获取线程的名字

（重要）static Thread currentThread()：获取当前正在运行的线程对象。

（重要）static void sleep(long millis)：线程休眠，　参数为休眠的时间，单位是毫秒

public class Demo02ThreadMethod {

public static void main(String[] args) {

//创建Thread子类对象，并且运行这个线程

MyThreadMethod mtm = new MyThreadMethod("如花");

//mtm.setName("狗蛋");

mtm.start();

//获取main线程的名字

//获取当前正在运行的线程对象，再通过这个线程对象调用getName方法，获取线程名字

//这个currentThread方法是由哪个线程执行的，那么获取到的就是哪个线程对象。

Thread t = Thread.currentThread();

System.out.println("main线程的名字是：" + t.getName());

// new MyThreadMethod().start();

}

3、（重要）static void sleep(long millis)：线程休眠，　参数为休眠的时间，单位是毫秒

public class Demo03Sleep {

public static void main(String[] args) throws InterruptedException {

System.out.println("开始");

//如果想让代码在执行过程中停一会儿，可以让线程休眠，使用的是sleep方法

Thread.sleep(2000);

System.out.println("结束");

}

4、多线程的第二种实现方式：

多线程的第二种实现方式（Runnable接口）

步骤：

1. 定义类，实现Runnable接口

2. 要重写这个接口中的run方法。要在run方法中定义线程要执行的任务。

3. 在测试类中创建Runnable接口的实现类对象。

4. 创建一个Thread线程对象，并且在构造方法位置传递Runnable接口的实现类对象，表示该线程要执行此任务。

5. 调用Thread对象的start方法，开始线程，让线程去运行。

多线程有两种实现方式：

1. 继承Thread类

2. 实现Runnable接口

第二种方式更好一些：

1. 实现Runnable接口的方式可以解决java中类与类之间只能单继承的局限性。

2. 降低类的耦合性(关联性)

3. Runnable接口中只有一个run方法，没有start，setName，getName其他的这些方法，我们只需要

在里面关注线程要执行的任务即可，这样这个功能就更加纯粹，更加专一，符合设计模式中的单一

职责原则.

4. 有利于实现多个线程之间的数据共享。

public class Demo04Runnable {

public static void main(String[] args) {

//在测试类中创建Runnable接口的实现类对象。

MyRunnableImpl r = new MyRunnableImpl();

//创建一个Thread线程对象，并且在构造方法位置传递Runnable接口的实现类对象，表示该线程要执行此任务

Thread t = new Thread(r); //表示线程t对象要执行的任务是r中的run方法

//调用线程对象的start方法

t.start();

for(int i = 1; i <= 1000; i++) {

System.out.println("HelloWorld:" + i);

}

5、匿名内部类

new 父类或者接口() {

重写的方法

}

匿名内部类真正创建的其实是子类对象。

public class Demo05ThreadInner {

public static void main(String[] args) {

//匿名内部类 + 继承Thread的方式实现多线程

Thread t = new Thread() {

@Override

public void run() {

System.out.println(getName() + "执行了");

}

};

t.start();

//匿名内部类 + 匿名对象 +　继承Thread的方式实现多线程

new Thread() {

@Override

public void run() {

System.out.println(getName() + "执行了");

}

}.start();

//匿名内部类 + 实现Runnable接口的方式实现多线程

Runnable r = new Runnable() {

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + "执行了");

}

};

//创建Thread对象，并直接开启线程

new Thread(r).start();

//匿名内部类 + 匿名对象 + 实现Runnable接口的方式实现多线程

new Thread(new Runnable() {

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + "执行了");

}

}).start();

}

6、MyRunnableImpl 不是线程类，因为这个类和Thread没有任何关系。

我们可以把这个类叫做线程任务类，因为这个类中定义的是线程要执行的任务，除此之外什么都没有。

public class MyRunnableImpl implements Runnable{

//run方法线程要执行的任务

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + "执行了");

for(int i = 1; i <= 1000; i++) {

System.out.println("HelloJava:" + i);

}

二、线程的安全问题

如果要解决线程安全问题，那么可以使用synchronized 关键字。

这个关键字表示的含义是同步。

它可以修饰代码块，也可以修饰方法。

如果synchronized 修饰代码块，那么这个代码块就是同步代码块。

格式：

synchronized(锁对象) {

//...

}

锁对象，专业叫法也叫作对象监视器。锁对象只是一个普通的对象，没有特殊的含义，只是做一个标记。

锁对象可以是任意引用类型的对象，可以是Object，ArrayList， Person， Student，String.....

作用：只有持有锁的线程，才能够进入到同步代码块。

public class Demo02TicketTest {

public static void main(String[] args) {

//创建Ticket2对象

Ticket2 t = new Ticket2();

new Thread(t).start();

}

1、如果synchronized 修饰方法，那么这个方法就是同步方法，也可以解决线程安全问题。

修饰符 synchronized 返回值类型方法名(参数列表) {

方法体;

}

作用：同步方法相当于把整个的方法体都加上了同步代码块。

同步方法也是有锁的。

如果这个方法是非静态的，那么锁对象是this。

如果这个方法是静态的，那么锁对象是当前类的Class对象（反射阶段），当前类.class

两种解决线程安全问题的方案：

1. 同步代码块

2. 同步方法

同步代码块的好处是使用起来非常灵活，可以对任意代码进行同步。格式稍微比同步方法要繁琐.

同步方法的好处是语法更加简洁。但是使用起来不如同步代码块灵活

public class Demo03TicketTest {

public static void main(String[] args) {

Ticket3 t = new Ticket3();

new Thread(t).start();

}

在jdk5之后，提供了一个java.util.concurrent包，这个包里面的内容都是和线程有关的。

里面有一个接口叫做Lock接口，这个接口的作用是可以手动的获取锁以及手动的释放锁。

void lock()：手动获取锁

void unlock()：手动释放锁

Lock是一个接口，如果要用，需要使用它的实现类 ReentrantLock

package cn.itcast.demo02;

@SuppressWarnings("all") //抑制警告

public class Ticket2 implements Runnable{

int num = 100;

//定义一个对象，这个对象表示锁对象

//锁对象没有特殊的含义，只是做一个标记

//多个线程必须使用同一个锁对象，否则不能保证线程安全。

Object lock = new Object();

@Override

public void run() {

while (true) {

//当线程执行到synchronized这句代码的时候，会看一下这个上面还有没有锁

//如果同步代码块上面还有锁，那么线程就获取到这个锁，然后进入到同步代码块中。

//如果同步代码块上面没有锁，那么这个线程就一直在这个位置等着获取锁，如果锁一直不来，那么就一直等着.

synchronized (lock) {

if(num > 0) {

try {

Thread.sleep(20);

} catch (InterruptedException e) {

}

System.out.println(Thread.currentThread().getName() + "正在卖票：" + num);

num--;

}

//当一个线程离开同步代码块，那么他会释放锁。

//之后其他线程就可以去竞争这个锁，谁抢到了，那么谁就去执行这个同步代码块。

}

3、多线程的六种状态

线程的六种状态（了解）：

新建（NEW）：当新建一个Thread，或者新建一个Thread子类对象时，这个线程处于此状态

运行（RUNNABLE）：当线程对象调用了start方法，线程就变成了运行状态。

受阻塞（BLOCKED）：当线程等待获取锁的时候，那么此线程就是受阻塞状态.

无限等待（WAITING ）：线程无限等待时，如果没有人通知我，我就一直等待。调用wait方法会让线程进入到无限等待状态，如果其他线程不唤醒这个线程，那么他就一直的等。

void wait()：导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。

wait， notify我们会在明天详细讲解.

计时等待（TIMED_WAITING）：计时等待等到某个时间如果别人不叫我，那么我就自己醒。调用sleep(毫秒值)或者 wait(毫秒值)会进入到计时等待

退出（TERMINATED）：当线程的run方法执行结束，或者调用了线程的stop方法。

4、Java中的死锁现象

package cn.itcast.demo04;

public class DeadLock implements Runnable{

//定义两个锁对象

Object lockA = new Object();

Object lockB = new Object();

//定义变量num，用来对死锁进行控制

int num = 0;

//是线程要执行的任务。

@Override

public void run() {

while(true) {

if(num % 2 == 0) {

synchronized (lockA) {

System.out.println("if...lockA");

synchronized (lockB) {

System.out.println("if...lockB");

}

} else {

synchronized (lockB) {

System.out.println("else...lockB");

synchronized (lockA) {

System.out.println("else...lockA");

}

num++;

}

package cn.itcast.demo04;

public class Demo01DeadLockTest {

public static void main(String[] args) {

//创建Runnable实现类对象

DeadLock deadLock = new DeadLock();

new Thread(deadLock).start();

}

补充知识点：

1、Callable接口

Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
ExecutorService：线程池类
- <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法
Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
使用线程池中线程对象的步骤：
- 创建线程池对象
- 创建Callable接口子类对象
- 提交Callable接口子类对象
- 关闭线程池

public class ThreadPoolDemo {

public static void main(String[] args) {

//创建线程池对象

ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象

//创建Callable对象

MyCallable c = new MyCallable();

//从线程池中获取线程对象,然后调用MyRunnable中的run()

service.submit(c);

//再获取个教练

service.submit(c);

//注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

//关闭线程池

//service.shutdown();

}

public class MyCallable implements Callable {

@Override

public Object call() throws Exception {

System.out.println("我要一个教练:call");

Thread.sleep(2000);

System.out.println("教练来了： " +Thread.currentThread().getName());

System.out.println("教我游泳,交完后,教练回到了游泳池");

return null;

}

Z次方-Y

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中多线程、同步、runnable、callable接口

一、多线程 1 多线程第一种方式的实现步骤（继承Thread类） 1、定义类重写Thread类； 2、重写里面的run方法，在run方法中定义线程要执行的任务。 3、创建Thread子类对象 4. 调用子类对象的start方法，启动线程。public class Demo01Thread { publ...
复制链接

扫一扫