Java基础学习——多线程

一、为什么要学习多线程
1.提高应用程序的响应，课增强用户体验
2.提高系统cpu的利用率
3.改善程序结构，将一个进程分为多个线程，便于理解和修改

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

三、优势

四、如何创建多线程
1.通过继承Thread类创建多线程，步骤如下
①创建一个子类继承多线程
②该子类重写run()
③创建该子类的实例
④子类对象调用start方法

package multiThreading.create;

/**
 * 多线程的创建方式一、继承Thread类
 * 1创建一个继承Thread类的子类
 * 2子类重写run() -->将线程执行的操作声明在run()
 * 3.创建子类对象
 * 4对象.start()
 *
 * <p>例子：遍历100内的偶数
 *
 * @author DaMeng
 * @create 2020-06-17 11:00
 * @description
 */
//1继承
class MyThread extends Thread {
    //2重写
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 50000; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+" :偶数" + i);
            }
        }
    }
}

public class Thread_Thread01 {
    public static void main(String[] args) {
        //3创建子类对象
        MyThread myThread1 = new MyThread();
        //4.调用start方法，启动当前线程&&JVM会调用该线程run方法
        myThread1.start();
       // 问题一、myThread1.run();直接调用run方法不会启动新线程，就是简单的方法调用
        //问题二、start方法只能执行一次，超过报异常
        MyThread myThread2 = new MyThread();
        myThread2.start();
        for (int i = 0; i < 50000; i++) {
            if (i % 2 == 1)
                System.out.println(Thread.currentThread().getName()+" :Here i am " + i);
        }
        System.out.println("Here i am");
    }
}

2.实现Runnable接口
①创建一个类实现Runnable接口
②该类重写run()
③创建该类实例
④创建Thread类实例，将③的对象以参数的形势传入构造方法
⑤Thread类实例调用start方法

package multiThreading.create;

/**
 * 创建多线程方式二：实现Runable接口
 * 1创建一个实现Runable接口的类
 * 2实现类实现抽象方法run（）
 * 3创建实现类的对象
 * 4对象作为参数传递到Thread类的构造器，创建Thread类对象
 * 5通过Thread类对象调用start()
 * <p>
 * 比较两种创建线程的方式
 * 优先选择实现Runable接口
 * 原因1.实现的方式没有类的单继承的局限性
 * 2.实现的方式更适合处理多个线程有共享数据的情况
 * <p>
 * 联系：Thread类实现Runable接口
 * 相同点两种方式都重写run(),将要执行的逻辑在run()中声明
 *
 * @author DaMeng
 * @create 2020-06-17 16:57
 * @description
 */
class MyThreadRunable implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票一张，票号：" + ticket + "剩余" + (ticket - 1) + "张");
                    ticket--;
                } else {
                    System.out.println("票已经卖完了");
                    break;
                }

            }
        }
    }
}

public class Thread_Runable02 {

    public static void main(String[] args) {
        MyThreadRunable myThreadRunable = new MyThreadRunable();
        Thread thread1 = new Thread(myThreadRunable);
        //调用该线程的run(),run()的实现过程为调用target.run(),target为构建线程时传递的参数
        thread1.setName("线程1");
        thread1.start();

        Thread thread2 = new Thread(myThreadRunable);
        thread2.setName("线程2");
        thread2.start();

        Thread thread3 = new Thread(myThreadRunable);
        thread3.setName("线程3");
        thread3.start();
    }
}

3.实现Callable接口
①创建实现Callable接口的类
②重写该类的call()
③创建实现Callable接口的类的对象C
④将C作为参数传入FutureTask类的对象(F)的构造方法
⑤创建Thread类并将F作为参数传入，调用call()方法

package multiThreading.create;

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

/**创建线程方式三、实现Callable接口  ---JDK5.0新增
 * 例：计算1到100的和
 *
 * 如何理解创建多线程时Callable比Runable更强大
 * 1。Callable有返回值
 * 2.Callable可以抛出异常
 * 3.Callable可以使用泛型
 *
 * @author DaMeng
 * @create 2020-06-19 8:50
 * @description
 */
//1.创建一个类实现Callable接口
class


NumThread implements Callable{
    private int sum = 0;
   //2.重写call()
    @Override
    public Object call() throws Exception {
        for (int i = 1; i <= 100 ; i++) {
            sum+=i;
            System.out.println(i);
        }
        System.out.println("1到100的总和:"+sum);
        return sum;
    }
}
public class Thread_Callable03 {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的实例
        NumThread numThread = new NumThread();
        //4.将Callable接口实现类对象作为参数传入FutureTask构造器，并创建对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将Future对象作为参数传入Thread类的对象中,并调用start()
        new Thread(futureTask).start();

        try {//获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数(Callable实现类子类)的call()的返回值
            Object sum = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

4通过线程池的方式
①创建线程池
②设置属性并执行指定的线程操作
	Ⅰexecute(Runnable runnable)
	Ⅱsubmit(Callable callable)
③关闭线程池
	shutdown()

package multiThreading.create;

import java.util.concurrent.*;

/**
 * 四、线程池创建
 * 背景:经常创建和销毁、使用量特别大的资源，比如并发时下的线程，对性能影响大
 * 思路:提前创建好多个线程,放入线程池，使用时直接获取，使用完放回池中
 * 好处
 * 1提高响应速度(减少了创建新线程的时间)
 * 2降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 * 3便于线程管理
 * corePoolSize核心池的大小
 * maximumPoolSize最大线程数
 * keepAliveTime线程没有任务，最多保持多长时间后会停止
 * 4相关API
 * JDK5.0后提供了线程池相关API：ExecutorService接口和Executors工具类
 * <p>
 * 使用步骤
 * 1.提供指定线程数量的线程池
 * ExecutorService service = Executors.newFixedThreadPool(10);
 * 2.执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象
 * service.execute(Runnable runnable)
 * service.execute(Callable callable)
 * 3.关闭线程池
 * service.shutdown()
 *
 * @author DaMeng
 * @create 2020-06-19 9:11
 * @description
 */
class OddThread implements Runnable {
    @Override
    public void run() {
        int j = 1;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + "输出第" + (j++) + "个偶数:" + i);
            }
        }
    }
}

class EvenThread implements Runnable {
    @Override
    public void run() {
        int j = 1;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 1) {
                System.out.println(Thread.currentThread().getName() + "输出第" + (j++) + "个奇数:" + i);
            }
        }
    }
}

class addThread implements Callable {
    private int sum = 0;

    @Override
    public Object call() throws Exception {
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println(Thread.currentThread().getName() + "计算了1-100的和");
        return sum;
    }
}

public class Thread_Pool04 {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        //ExecutorService service = Executors.newFixedThreadPool(10);
        //典型多态可以直接进行强转，返回the newly created thread pool
        ThreadPoolExecutor service = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);

        //设置线程池的属性
        service.setCorePoolSize(10);
        service.isShutdown();
        //2.执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象
        //service.execute(Runnable runnable)
        service.execute(new OddThread());
        service.execute(new EvenThread());
        //service.submit(Callable callable)
        FutureTask futureTask = (FutureTask) service.submit(new addThread());
        try {
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //关闭连接池
        service.shutdown();
    }
}

五、线程安全问题
多个线程同时操作一个变量可能会产生线程安全问题，
解决方法
1.通过同步代码块
将synchronized(){}代码块包含对共享数据进行操作的代码，其中参数为任意对象即可(该对象具有唯一性，即多个线程共用该对象)

 2.同步方法
 将对共享数据的操作抽象为一个方法，定义该方法时用synchronized进行修饰
 3.ReentrantLock对象的lock()和unLock()
 实例化ReentrantLick，调用lock()加锁,unLock()进行解锁

六、线程通信问题
1.使用wait(),notify().notifyAll()
线程调用wait()方法则进入阻塞状态，其他线程调用notify()方法则随机唤醒一个线程，优先唤醒一个优先级高的线程，notifyAll()唤醒所有的线程