JAVA SE之多线程

最新推荐文章于 2024-09-15 09:47:04 发布

比奇堡的收银员

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量73

点赞数

分类专栏：笔记 MySQL数据库文章标签： java

本文链接：https://blog.csdn.net/can_remember/article/details/117457153

版权

笔记同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

MySQL数据库

6 篇文章 0 订阅

订阅专栏

1.基本概念

程序（program）：静态代码。
进程（process）：正在运行的程序。
线程（thread）：进程内部的一条执行路径。

每个线程都有虚拟机栈和程序计数器，而每个进程都有方法区和堆，
也就是说多个线程共享一个进程的方法区和堆，jvm的调优也都是从
方法区和堆展开的。

1.1并行与并发

并行：多个CPU同时处理多个任务。
并发：一个CPU（采用时间片）同时执行多个任务。

1.2多线程程序的优点

1.提高应用程序的响应。对图形化界面更有意义，可增强用户的体验。
2.提高计算机系统的CPU的利用率。
3.改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

1.3何时需要多线程

1.程序需要同时执行两个或多个任务。
2.程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
3.需要一些后台运行的程序时。

2.线程的创建和使用

2.1创建多线程的方式

继承Thread类

1.创建一个继承Thread类的子类
2.重写Thread类的run方法
3.创建Thread类的子类的对象
4.通过此对象调用start()

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
        
        }
    }

实现Runnable接口

1.创建一个实现Runnable接口的类
2.实现类去实现Runnable接口的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()

class MThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread()+":"+i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        MThread m = new MThread();
        Thread t1 = new Thread(m);
        t1.setName("线程一");
        t1.start();
        Thread t2 = new Thread(m);
        t2.setName("线程二");
        t2.start();
    }
}

总结：联系：public class Thread implements Runnable
Thread也实现了Runnable接口
相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中

比较两种创建方式：开发中：优先选择实现Runnable接口的方式
原因：1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况

Lock锁-----JDK5.0新增

1.实例化ReentrantLock
2.调用锁定方法：lock()
3.调用解锁方法：unlock()

class Window05 implements Runnable {
    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                lock.unlock();
            }

        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window05 w = new Window05();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");
        t1.start();
        t2.start();
        t3.start();
    }
}

实现Callable接口--------JDK5.0新增

 Callable比Runable接口强大的原因
1.call()可以有返回值的。
2.call()可以抛出异常，被外面的操作捕获，获取异常的信息
3.callable是支持泛型的

class ThreadNew implements Callable {

    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;

            }
        }return sum;
    }
}
public class NumThread {
    public static void main(String[] args) {
        ThreadNew threadNew = new ThreadNew();
        FutureTask futureTask = new FutureTask(threadNew);
        new Thread(futureTask).start();
        try {
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

使用线程池

线程池的优点
1.提高响应速度（减少创建新线程的时间）
2.减低资源消耗（重复利用线程池的线程，不需要每次都创建）
3.便于线程管理
  corePoolSize:核心池的大小
  maximumPoolSize:最大线程数
  keepAliveTime:线程没有任务时最多保持多长时间会被终止

class ThreadNumber implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new ThreadNumber());
        service.shutdown();
    }
}

2.2测试Thread中的常用方法

1.start()：启动当前线程；调用当前线程的run()
2.run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3.currentThread()：静态方法，返回执行当前代码的线程
4.getName()：获取当前线程的名字
5.setName()：设置当前线程的名字
6.yield()：释放当前CPU的执行权
7.join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，知道线程b完全执行完以后
线程a才结束阻塞状态
8.stop()：已过时。执行当前此方法时，强制结束当前线程。
9.sleep(long millitime)：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime 毫秒时间内，
当前状态是阻塞状态。
10.isAlive():判断当前线程是否存活

2.3线程优先级

1.线程优先级：MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5

2.获取和设置当前线程的优先级（设置只能提高概率，不意味着绝对优先）
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级

2.4线程分类

一种是守护线程，一种是用户线程

3.线程的生命周期

4.线程安全问题

4.1使用同步代码块解决线程安全问题

synchronized(同步监视器){
              //需要被同步的代码
}
说明：1.操作共享数据的代码，既需要被同步的代码
          2.共享数据：多个线程共同操作的变量。
          3.同步监视器，俗称：锁。任何一个类的对象都可以充当锁
             要求：多个线程必须要共用同一把锁。

4.2使用同步方法解决线程安全问题

关于同步方法的总结：
1.同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
2.非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是：当前类本身

5.线程通信

涉及到三个方法：
wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的线程
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
说明：
1.wait(),notify(),notifyAll()三个方法必须使用在同一个同步代码块或同步方法中。
2.wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器
否则，会出现IllegalMonitorStateException异常
3.wait(),notify(),notifyAll()三个方法是定义在java.lang.object类中

思考：sleep()和wait()的异同？
1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
2.不同点：1.两个方法声明的位置不同：Thread类中声明sleep()，object类中声明wait()
2.调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中
3.关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。