小白学Java第五天、第六天

最新推荐文章于 2024-09-27 00:45:01 发布

dragon__ran

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量1.3k

点赞数 42

文章标签： java 开发语言

本文链接：https://blog.csdn.net/dragon__ran/article/details/134814161

版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

说起线程就不得不提起进程，说起进程就不得不提起程序
程序是指令和数据的有序集合，是一个静态概念。
进程则是执行程序的一次执行过程，他是一个动态的概念。是系统资源分配的单位
通常在一个进程中可以有若干个线程，当然一个进程中至少有一个线程，线程是CPU调度和执行的单位

一、Thread是什么？

线程是独立的执行路径；
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
main()称之为主线程，为系统的入口，用于执行整个程序；
在一个线程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的；
对同一份资源的操作时，会存在资源抢夺的问题，需要加入并发控制；
线程会带来额外的开销，如cpu调度时间，并发控制开销；
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

二、创建方式

1. Thread class：继承Thread类

定义MyRunnable类实现Runnable接口

public class MyThread extends Thread{
    
}

重写run()方法，编写线程执行体

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我是线程第"+i+"次");
        }
    }
}

创建线程对象，调用start()方法启动线程

 public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        
    }

2. Runnable 接口：实现Runnable接口

定义MyThread类继承Thread类

public class MyRunnable implements Runnable{
    
}

重写run()方法，编写线程执行体

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我是线程第"+i+"次");
        }
    }
}

创建线程对象，new Thread(目标对象).start()方法启动线程

public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        new Thread(myRunnable).start();
    }

3. Callable接口：实现Callable接口

实现Callable接口，需要返回值类型

public class MyCallable implements Callable<Boolean> {

重写run()方法，需要抛出异常

public class MyCallable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("我是线程体第"+i+"次");
        }
        return true;
    }

创建目标对象

MyCallable myCallable = new MyCallable();

创建执行服务

ExecutorService ser = Executors.newFixedThreadPool(1);

提交执行

 Future<Boolean> result = ser.submit(myCallable);

获取结果

 Boolean aBoolean = result.get();

关闭服务

ser.shutdownNow();

4. Lambda表达式

避免匿内部类定义过多
让代码看起来很简洁
去掉没有意义的代码，留下核心逻辑

new Thread(()->System.out.println("多线程学习")).start();

函数式接口：只包含唯一的一个抽象方法，对于函数式接口，可以使用Lambda表达式来创建该接口的对象`

package com.huang.thread;

//实现接口
public class Lambda01 implements Runnable01 {

    //重写方法
    @Override
    public void run01() {

    }


    public static void main(String[] args) {

        //Lambda表达式调用
        Runnable01 run = ()->{
            for (int i = 0; i < 100; i++) {
                System.out.println("第"+i+"次");
            }
        };
       run.run01();
    }
}
//函数式接口
interface Runnable01 {
    public abstract void run01();
}

二、线程状态

1.五大状态

创建状态：Thread thread = new Thread()线程对象一但创建就进入到了新生状态
就绪状态：当调用start()方法，县城立即进入就绪状态，但不意味着立即调度执行
运行状态：进入运行状态，县城才真正执行线程体的代码块
阻塞状态：当调用sleep,wait 或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行
死亡状态：线程中断或者结束，一旦进入死亡状态，就不能再次启动

2.停止线程

不推荐使用JDK提供的stop()、destroy()方法
建议使用一个标志进行终止变量终止线程运行

public class TestStop implements Runnable {

    private boolean flag=true;
    @Override
    public void run() {
        int i=0;
       while (flag){
           System.out.println("Run"+i++);
       }
    }

    public  void stop(){
        this.flag=false;

    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(10);//线程过快，添加一个休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i==50){
                testStop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

3.线程休眠

sleep（时间）指定当前线程阻塞的毫秒数；
sleep存在异常InterruptedException；
sleep时间到达后线程进入就绪状态；
sleep可以模拟网络延时，倒计时等；
每个对象都有一个锁，sleep不会释放锁

try {
                Thread.sleep(10);//线程过快，添加一个休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

4.线程礼让

Thread.yield();
礼让线程，让当前线程暂停，但不阻塞
让cpu重新调度，礼让不一定成功！看CPU心情

5.线程插队

thread.join();
等待此线程执行完后，再执行其他线程，其他线程阻塞

6.线程状态观测

NEW ：尚未启动的线程处于此状态
RUNNABLE：在JVM中执行的线程处于此状态
BLOCKED：被阻塞等监视器锁定的线程处于此状态
WAIRING：正在等待另一个线程执行特定动作的线程处于此状态
TIMED_WAITING：正在等待另一个线程执行特定动作达到指定等待时间的线程处于此状态
TERMINATED：已退出的线程处于此状态

7.线程优先级

线程的优先级用数字表示，范围从1-10，默认是5
使用getPriority() 获取优先级
使用setPRriority() 改变优先级
注意：
优先级的设定要在start（）调度前
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了。

8.守护线程

Daemon
线程分为用户线程和守护线程；默认是用户线程
JVM必须保证用户线程执行完毕，不用等待守护线程执行完毕

三、线程同步

1.什么是线程同步

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象这时候就需要线程同步，线程同步是一种等待机制，多个需要同时此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕，下一线程再使用。

2.线程同步方法

由于使用private关键字保证数据对象只能被方法访问，所以只需要使用synchronized方法和synchronized快使线程同步

synchronized方法控制对象的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程阻塞
方法一旦执行，就独占该锁直到该方法返回才释放锁，后面被阻塞的线程才能获得锁继续执行

同步块synchronized（Obj）{}
Obj称之为同步监视器
可以是任何对象，但是推荐使用共献资源作为同步监视器
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或是class
同步监视器的执行过程
1.第一个线程访问﹐锁定同步监视器﹐执行其中代码﹒
2.第二个线程访问﹐发现同步监视器被锁定﹐无法访问．
3.第一个线程访问完毕﹐解锁同步监视器．
4.第二个线程访问,发现同步监视器没有锁﹐然后锁定并访问

3.线程同步存在的问题

一个线程持有锁会导致其他所有需要次锁的线程挂起
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时使性能下降
一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置

4.死锁

多个线程各自占有一些共享资源﹐并且互相等待其他线程占有的资源才能运行﹐而导致两个或者多个线程都在等待对方释放资源﹐都停止执行的情形.某一个同步块同时拥有“两个以上对象的锁”时﹐就可能会发生“死锁”的问题.
死锁避免的方法
产生死锁的四个必要条件:
1.互斥条件:一个资源每次只能被一个进程使用。
2．请求与保持条件:一个进程因请求资源而阻塞时，对已获得的资源保持不放3.不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺
4．循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
只要想办法破解其中的任意一个或多个条件就可以不免死锁发生

5.Lock

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁,
线程开
始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

6.Synchronized与Lock的对比

Lock是显式锁（(手动开启和关闭锁，别忘记关闭锁) syachronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
优先使用顺序:
Lock >同步代码块（已经进入了方法体，分配了相应资源)>同步方法（在方法体之外)

7.线程池

思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完放
回池中。
可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
提高响应速度（减少了创建新线程的时间)
降低资源消耗（重复利用线程池中线程，不需要每次都创建)便于线程管理(……)
corePoolSize:核心池的大小maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止

线程池的创建和使用

public class TestPool {
    public static void main(String[] args) {
        //创建实例对象
        MyThreadPool myThreadPool = new MyThreadPool();
        //创建服务
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.execute(myThreadPool);
        service.execute(myThreadPool);
        service.execute(myThreadPool);
        service.execute(myThreadPool);

        //关闭服务
        service.shutdown();



    }
}

class MyThreadPool implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}