Java-多线程

最新推荐文章于 2024-08-04 11:07:52 发布

江東-H

最新推荐文章于 2024-08-04 11:07:52 发布

阅读量314

点赞数

分类专栏： Java 文章标签： java jvm 面试

本文链接：https://blog.csdn.net/heima005/article/details/129436943

版权

Java 专栏收录该内容

28 篇文章 2 订阅

订阅专栏

多线程

大总结:

创建线程的第一种方式: 继承Thread类
创建线程的第二种方式 : 实现Runnable接口
创建线程的第三种方式 : 实现Callable接口
线程的生命周期分别是 : 统新建 , 就绪 , 阻塞 , 运行 , 死亡
同步代码块格式 : synchronized(任意对象) { 多条语句操作共享数据的代码 }
同步方法格式 : 统修饰符 synchronized 返回值类型方法名(方法参数) { }
死锁产生的原因 : 线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行

实现多线程方式一（5★）:

实现步骤:

1： 定义一个类MyThread继承Thread 类。

2： 重写run方法 把你想让线程做的内容写在run方法中。

3： 在测试中类 创建这个类的对象。

4： 不是调用run方法。 而是调用start方法。线程就开启了。

代码实现:

class MyThread extends Thread{
    @override
    public void run(){
        //线程执行内容
    }
}

public class Text{
    public static void main(String[] args){
        MyThread mt = new MyThread();
        mt.start();
        //线程任务和线程本身耦合性太强
    }
}

优缺点:

1, 书写简单,方便
2, 线程任务和线程本身耦合在一起了

线程的实现方式二(5★）：

实现步骤:

1: 定义一个类MyRunnable实现Runnable接口

2: 在MyRunnable类中重写run()方法

3: 创建MyRunnable类的对象

4: 创建Thread类的对象，把MyRunnable对象作为构造方法的参数

5: 让Thread 的对象调用 start();

代码实现:

class MyRunnable implements Runnable{
	@override
    public void run(){
        //线程执行内容
    }
}

public class Text{
    public static void main(String[] args){
    	MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr);
        t.start();
    }
}

优缺点:

1, 书写起来多一步
2, 线程任务和线程本身 相分离

线程的实现方式三（4★）

实现步骤:

1,定义一个类MyCallable实现Callable接口

2,在MyCallable类中重写call()方法

3,创建MyCallable类的对象

4,创建FutureTask对象，把MyCallable对象作为构造方法的参数

5,创建Thread类的对象，把FutureTask对象作为构造方法的参数

6,让Thread 的对象调用 start();

7,再用FutureTask对象调用get方法，就可以获取线程结束之后的结果。

代码实现:

class MyCallable implements Callable<String>{
    @override
    public void call() throws Exception{
         //线程执行内容
        
        return "字符串";
    }
}
public class Text{
    public static void main(String[] args){
    	MyCallable mc = new MyCallable();
        FutureTask ft = new FutureTask(mc);
        Thread t = new Thread(ft);
        t.start();
        String s = ft.get(); //get方法的底层 有等待唤醒机制,然后获取返回值 需要throws一个异常
    }
}

优缺点:

1,代码复杂
2,可接收线程结束后返回值

线程的方法:

1,void setName(String name)  更改此线程的名称

2,nameString getName()  获取此线程的名称

3,Thread currentThread()  返回对当前正在执行的线程对象的引用

4,static void sleep(long millis)  使当前正在执行的线程停留（暂停执行）指定的毫秒数
    
5,final int getPriority()  返回此线程的优先级
    
6,final void setPriority(int newPriority) 更改此线程的优先级线程,默认优先级是5；线程优先级的范围是：1-10
    
7,void setDaemon(boolean on)  将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

安全问题:

安全问题原因：

1,是多线程环境

2,有共享数据

3,有多条语句操作共享数据

同步代码块解决问题：

同步代码块格式:

synchronized(任意对象) { 
	多条语句操作共享数据的代码 
}

优缺点:

好处：解决了多线程的数据安全问题
弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

同步方法

就是把synchronized关键字加到方法上

同步方法格式:

修饰符 synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}

静态同步方法

就是把synchronized关键字加到静态方法上

同步静态方法格式:

修饰符 static synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}
  //同步静态方法的锁对象是  类名.class

Lock锁

定义:

1, 创建ReentrantLock对象
	Lock lock = new ReentrantLock(); 
	
2, 加锁解锁方法
	lock.lock();
	lock.unlock();

死锁

原因:

1, 资源有限

2, 同步嵌套

避免:

开发中应当尽量避免锁的嵌套

Object类的等待和唤醒方法

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

void notify()   唤醒正在等待对象监视器的单个线程  

void notifyAll()   唤醒正在等待对象监视器的所有线程

阻塞队列基本使用

阻塞队列

常见BlockingQueue:

lockingQueue:

	ArrayBlockingQueue:  底层是数组,有界

	LinkedBlockingQueue:  底层是链表,无界.但不是真正的无界,最大为int的最大值

构造方法

 ArrayBlockingQueue<Object> abq = new ArrayBlockingQueue<>(int capacity)
 
 LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<>()  //创建一个容量为 Integer.MAX_VALUE
 LinkedBlockingQueue(int capacity)  //创建一个具有给定（固定）容量的

核心方法

put(anObject):  将参数放入队列,如果放不进去会阻塞

take():  取出第一个数据,取不到会阻塞

线程状态

NEW  : 尚未启动的线程处于此状态。 

RUNNABLE  :在Java虚拟机中执行的线程处于此状态。 

BLOCKED  :被阻塞等待监视器锁定的线程处于此状态。 

WAITING  :正在等待另一个线程执行特定动作的线程处于此状态。 

TIMED_WAITING  :正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。 

TERMINATED  :已退出的线程处于此状态。