Java之多线程基础

首先我们来了解一些概念

程序：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

进程 ：程序的一次执行过程，或是正在运行的一个程序。

线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。

进程可以细化为多个线程。

每个线程，拥有自己独立的：栈、程序计数器。

多个线程，共享同一个进程中的结构：方法区、堆。

△一个Java应用程序java.exe，其实至少三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行 与 并发 的区别：

并行：在同一时刻，多个CPU同时执行多个任务

并发 ：在同一时刻，一个CPU交替执行多个任务

实现多线程的四种方式：

①：继承Thread类

public class MyThread extends Thread { //定义一个类MyThread继承Thread类
    @Override
    public void run() {    //在类中重写run（）方法
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}

public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();    //创建MyThread类的对象
        MyThread my2 = new MyThread();

        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
        my1.start();        //启动线程
        my2.start();
    }
}

②：实现Runnable接口

//定义一个类实现Runnable接口
public class MyRunnable implements Runnable {   
//在MyRunnable类中重写run()方法
    @Override
    public void run() {
       System.out.println("我是" + Thread.currentThread().getName);         
    }
}

public class MyRunnableDemo {
    public static void main(String[] args) {
//创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();

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

        //Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"坦克");
        Thread t2 = new Thread(my,"飞机");

        //启动线程
        t1.start();
        t2.start();
    }
}

③：实现Callable接口(JDK5.0新增）

好处：

* 1. call()可以返回值的。
* 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
* 3. Callable是支持泛型的

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
    @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 ThreadNew {
    public static void main(String[] args) {
//3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }

}

④使用线程池

好处：
* 1.提高响应速度（减少了创建新线程的时间）
* 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
* 3.便于线程管理

public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);   //核心池的大小
//        service1.setKeepAliveTime();    //线程没任务时最多保持多长时间后会终止


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
}

 

 

Thread类中的常用方法

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

 线程的优先级：

方法名	说明
getPriority()	获取线程的优先级
setPriority(int p)	设置线程的优先级(0-10)默认为5

 *****说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。

线程同步：

 ——经典问题：卖票出现多次相同票或者负数的票。

 ——条件：多线程环境；有共享数据；有多条语句操作共享数据

解决方案：

①同步代码块

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

缺点：线程多时，每个线程都会判断同步上的锁，耗费资源，降低运行效率。 

②同步方法（锁的是this对象）

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

③静态同步方法（锁的对象是  类名.class）

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

④Lock锁（是接口不能直接实例化，可以用它的实现类；例如：ReentrantLock）

方法名	说明
lock（）	获得锁
unlock（）	释放锁

***死锁问题：线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。

        Object o1 = new Object();
        Object o2 = new Object();
        //lambda表达式
        new Thread(() -> {
            while (true){
                synchronized (o1){
                    synchronized (o2){
                        System.out.println("o1出来啦");
                    }
                }
            }
        }).start();

        new Thread(() -> {
            while (true){
                synchronized (o2){
                    synchronized (o1){
                        System.out.println("o2出来啦");
                    }
                }
            }
        }).start();