Java多线程技术概述

程序、进程和线程区别

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

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间；

线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程。

线程调度

分时调度：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间；

抢占式调度：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机；

Java使用的为抢占式调度。

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高。

并发和并行

并发：指两个或多个事件在同一个时间段内发生；
并行：指两个或多个事件在同一时刻发生（同时发生）。

Java多线程的实现方式

1.继承Thread类

1)自定义线程类

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

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

package tiz.test.多线程;
//利用Thread来实现多线程，构造自己的Thread继承自Thread
//重写run方法，就是一个子线程
public class myThread extends Thread{
    @Override
    public void run() {
        for (int i =0;i<10;i++){
            System.out.println("锄禾日当午"+i);
        }
    }
}

package tiz.test.多线程;
/**
 * 多线程的实现
 *@author Tiz_liu
 */
//每个线程都有自己的栈空间，共用一份堆内存。
public class Demo1 {
    public static void main(String[] args) {
        myThread m =new myThread();
        m.start();//调用start方法，而不是run
        for (int i =0;i<10;i++){
            System.out.println("汗滴禾下土"+i);
        }
    }
}

2.实现Runnable接口

1)定义MyRunnable类实现Runnable接口

2)实现run()方法，编写线程执行体

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

package tiz.test.多线程;
public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i =0;i<10;i++){
            System.out.println("床前明月光"+i);
        }
    }
}

package tiz.test.多线程;
public class Demo2 {
    /**
     * 多线程技术
     * 实现runnnable与继承Thread的优点
     * 1.通过创建任务，然后给线程分配的方式来实现多线程，更适合多个线程同时执行相同任务的情况
     * 2.可以避免单继承带来的局限性
     * 3.任务与线程分类，提高了程序的健壮性
     * 4.后续的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程
     */
    public static void main(String[] args) {
        //1.创建一个任务
        MyRunnable r = new MyRunnable();
        //2.创建一个线程
        Thread t = new Thread(r);
        //3.执行线程
        t.start();
        for (int i =0;i<10;i++){
            System.out.println("疑是地上霜"+i);
        }
    }
}

3.实现Callable接口

多线程不安全解决方案

1.同步代码块

同步块：synchronized (o) {}

package tiz.test.多线程;
public class Demo6_1 {
    //线程安全不安全
    //解决方案1.同步代码块
    //格式：synchronized(锁对象){}
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();

    }
    static class Ticket implements Runnable{
        //票数
        private  int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            while (true){
                synchronized (o){
                    //卖票
                    if(count>0){
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"出票成功，余票"+count);
                    }else{
                        break;
                    }

                }

            }

        }
    }
}

2.同步方法

public synchronized void method（int args）{}

package tiz.test.多线程;

public class Demo6_2 {
    //线程安全不安全
    //解决方法2.同步方法
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();

    }
    static class Ticket implements Runnable{
        //票数
        private  int count = 10;

        @Override
        public void run() {
            //卖票
            while (true){
                boolean flag = safe();
                if (!flag){
                    break;
                }

            }
        }
        public synchronized boolean safe(){//同步方法
            if(count>0){
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"出票成功，余票"+count);
                return true;
            }else{
                return false;
            }
        }
    }

}

3.显式锁Lock

package tiz.test.多线程;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo6_3 {
    //线程安全不安全
    //解决方法3.显示锁Lock 子类 ReentrantLock
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();

    }
    static class Ticket implements Runnable{
        //票数
        private  int count = 10;
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
            while (true){
                //卖票
                l.lock();
                if(count>0){
                    System.out.println("正在准备卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，余票"+count);
                }else{
                    break;
                }
                l.unlock();
            }

        }
    }

}

显式锁和隐式锁

隐式锁：synchronized；

显式锁：lock

所谓的显示和隐式就是在使用的时候，使用者要不要手动写代码去获取锁和释放锁的操作。

在使用sync关键字的时候，我们使用者根本不用写其他的代码，然后程序就能够获取锁和释放锁了。那是因为当sync代码块执行完成之后，系统会自动的让程序释放占用的锁。Sync是由系统维护的，如果非逻辑问题的话话，是不会出现死锁的。

在使用lock的时候，我们使用者需要手动的获取和释放锁。如果没有释放锁，就有可能导致出现死锁的现象。手动获取锁方法：lock.lock()。释放锁：unlock方法。需要配合tyr/finaly语句块来完成。

公平锁和非公平锁

是否按照申请锁的顺序去获得锁

Sync;非公平锁

lock：两者都可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。

true：公平锁

false：非公平锁

线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的优点

降低资源消耗。

提高响应速度。

提高线程的可管理性。