2021-04-07

最新推荐文章于 2024-07-24 21:47:59 发布

nanhanlu

最新推荐文章于 2024-07-24 21:47:59 发布

阅读量64

点赞数

文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_44253637/article/details/115481814

版权

多线程

1.多线程概念
进程：正在执行的程序
单线程：一个进程中只有一条执行路劲
多线程：一个进程有多条执行路径

2.java种多线程类：Thread
2.1 构造方法(常用)：
(1)Thread();
(2)Thread(Runnable target)
2.2 常用方法:
(1) setName(),getName(): 设置与得到线程名。
（2）getPriority(), setPriority(): 得到与设置线程优先级。（优先级最低为1，最高为10，默认为5）
（3）strat():启动线程
（4）run():重写该方法，线程的具体操作逻辑
（5）sleep(毫秒值):阻塞线程指定时间
（6）join():该线程执行完之后才可以执行其他线程
（7）yeild():释放当前cpu资源。
3.java中实现多线程方法
3.1继承Thread类，重写run（）方法，使用start（）启动线程：
3.1.1继承Thread类，重写run（）

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i = 0;i<99;i++) {
            System.out.println(Thread.currentThread().getName()+":");

        }
    }
}

3.1.2 测试类，使用start（）启动线程：

import org.junit.Test;

public class TestDemo1 {
    @Test
    public void test() {
        MyThread t1 = new MyThread();
        t1.setName("线程一");
        MyThread t2 = new MyThread();
        t2.setName("线程二");

        //System.out.println(t1.getName());
        t1.start();
        t2.start();
    }

}

3.2 实现Runnable 接口，创建线程，启动线程
3.2.1 实现Runnable 接口，重写run()方法

public class Windows  implements  Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":"+123);

    }
}

3.2.2启动线程

package com.java.Thread.creat.menthod2;

public class TestDemo1 {
    public static void main(String[] args) {
        Windows w = new Windows();
        Thread t = new Thread(w,"线程一");
//        System.out.println(t.getName());
        t.start();

    }
}

3.3实现Callable接口，创建线程，启动线程,同时该方法支持泛型
用该方法实现时需要使用FutureTask类，具体代码如下：
3.3.1创建实现类，重写cal方法（类似3.2中的run方法）

import java.util.concurrent.Callable;

public class MyColl implements Callable {
    private int sum = 0;
    @Override
    public Object call() throws Exception {

        for(int i = 0;i<100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
                sum+=i;
            }
        }
        return sum;
    }
}

测试类，启动线程

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestDemo {
    public static void main(String[] args) {
        MyColl cl = new MyColl();
        //调用，得到对象
        FutureTask futureTask = new FutureTask(cl);
        Thread t1 = new Thread(futureTask,"线程一");
        t1.start();
        //调用futureTask.get()得到返回值
        try {
            Object num = futureTask.get();
            System.out.println(num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

3.3.2，实现Callable接口与实现Runnale接口的异同：
相同点：都用来创建线程
不同点：Callable接口功能更加强大，可以有返回值，可以在方法上剖出异常，支持泛型。

3.4使用线程池创建线程
3.4.1相关API
3.4.1.1ExecutorService：线程池接口，常用实现类有：ThreadPoolExecutor
也可以使用Executors.newFixedThreadPool(num)获得最大线程num个的类。
主要方法：execute(args)//参数为实现runnable接口的实现类
submit(args)//参数为实现Callable接口的实现类
3.4.1.2Executors：工具类。

3.4.2具体代码
3.4.2.1实现类

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

3.4.2测试类

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class TestDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor wx1 = (ThreadPoolExecutor) executorService;//将接口类换成实现类，可以调用相关方法设置参数
        Windows w1 = new Windows();
        executorService.execute(w1);//需要Runnable接口实现类
//        executorService.submit();//需要Callable接口实现类
        executorService.shutdown();
    }
}

4.线程的生命周期

5.线程同步情况
5.1线程同步概述
5.1.1使用情况：当多个线程运行时有共享数据时，会发生线程安全问题

5.1.2问题引入：有三个窗口卖100张票，当每个窗口卖出一张票时，打印该窗口当前时第几张票。
分析：三个窗口，三个线程，代码引入:
窗口类

public class Windows  implements  Runnable{
    private int tickets = 100;
    @Override
    public void run() {
       while(true){
           if(tickets>0){
               System.out.println(Thread.currentThread().getName()+"卖出第"+tickets+"票");
               tickets--;
           }else{
               break;
           }
       }

    }
}

测试类：

public class TestDemo1 {
    public static void main(String[] args) {
        Windows w = new Windows();
        Thread t1 = new Thread(w,"窗口一");
        Thread t2 = new Thread(w,"窗口二");
        Thread t3 = new Thread(w,"窗口三");
//        System.out.println(t.getName());
        t1.start();
        t2.start();
        t3.start();

    }
}

程序输出出现问题：第100张票会被卖出好几次，同时有小于0的票出现
为更加符合实际，每个窗口出票都需要一定时间：

public class Windows  implements  Runnable{
    private int tickets = 100;
    @Override
    public void run() {
       while(true){
           if(tickets>0){
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println(Thread.currentThread().getName()+"卖出第"+tickets+"票");
               tickets--;
           }else{
               break;
           }
       }

    }
}

5.2解决方法：
5.2.1java中给出了同步代码块与同步代码类方法解决：
5.2.1.1同步代码块：在多个线程共享数据操作的代码块前加上synchronized (Object obj)修饰，注意，其中obj在多个线程执行时需要使用同一个obj来进行同步：

public class Windows  implements  Runnable{
    private int tickets = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出第" + tickets + "票");
                    tickets--;
                } else {
                    break;
                }
            }

        }
    }
}

5.2.1.2同步代码类方法
如果共享数据代码块正好在一个方法内，可以直接在方法前加上synchronized修饰该方法（在返回类型修饰符之前）,该方法默认使用this对象作为锁

public class Windows  implements  Runnable{
    private int tickets = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while (true) {
            show(tickets);
               
        }
    
}
public synchronized void show(int tickets){
 if (tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出第" + tickets + "票");
                    tickets--;
                } else {
                    break;
                }
            }
}

5.2.1.3以上两种具体代码适合于使用实现Runnable接口实现的多线程安全问题，对于直接继承Thread的多线程，与上面的代码有些不同：
对于同步代码块来说，作为锁的对象一般为windows.class
对于同步代码方法，其方法应当是静态的。（锁的对象为windows.class）

5.2.2Lock锁解决线程安全问题
5.2.2.1 Lock是java种的接口，一般使用ReentrantLock实现该接口，使用该方法代码如下

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Windows  implements  Runnable{
    private int tickets = 100;
//    Object obj = new Object();
    ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                //同步代码块
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出第" + tickets + "票");
                    tickets--;
                } else {
                    break;
                }
            }finally {
                lock.unlock();
            }

        }
    }
}

Lock与synchronized不同点：（1）Lock是显示的，手动的，而synchronized自动的
（2）Lock只能锁代码块
（3）Lock性能更好。

6.线程中一些其他相关知识点
6.1线程的通信：即存在线程的唤醒与进入阻塞状态，相关方法：sleep(),wait(),notify(),notifyAll().
6.2问题引入，线程交替打印数字，生产者消费者模型。
6.2.1交替打印数字
6.2.1.1线程打印数字实现类（不可以实现交替打印）：


public class Window implements  Runnable {
    private  int num = 0;
    @Override
    public void run() {
        while(true) {
            synchronized (Window.class) {
                if (num < 100) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + num);
                    num++;
                } else {
                    break;
                }
            }
        }
    }
}

6.2.1.2改进（可以实现交替打印）:

public class Window implements  Runnable {
    private  int num = 0;
    @Override
    public void run() {
        while(true) {
            synchronized (this) {
                if (num < 100) {
                    notify();
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + num);
                    num++;
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

解析：有两个线程，1和2，当线程1（假设线程1先执行）执行该线程时，到了wait（）方法时进入阻塞状态，线程2开始执行线程，使用notify()唤醒阻塞状态的线程1，同时因为同步代码块，只有等线程2执行完后才可以，此时线程2到了wait（）方法时进入阻塞状态，线程1开始执行，使用notify()唤醒阻塞状态的线程1…。
测试类：

public class TestDemo {
    public static void main(String[] args) {
        Window w1 = new Window();
        Thread t1 = new Thread(w1,"用户一");
        Thread t2 = new Thread(w1,"用户二");
        t1.start();
        t2.start();

    }



}

6.2.1.3注意事项，以及wait与sleep之间的比较：
6.2.1.3.1注意事项：因为wait()与notify()方法都是静态方法，调用它们的对象是同步代码块中的同步监视器，即同步监视器.wait()与同步监视器.notify()。
6.2.1.3.2wait与sleep之间的比较：（1）sleep()不会释放锁，声明在Thread中
（2）wait()会释放锁，只能在同步代码块与同步方法中，声明在Object中。