多线程基础

一、基本含义:

1.程序:用某种语言编写的一组指令的集合,是一段静态的代码
2.进程:进程作为资源分配的单位.正在运行的程序,是一个动态的过程,有它自身的产生,存在和消亡的过程—生命周期
3.线程:程序内部的一条执行路径.一个进程可以有多个线程.线程作为调度和执行的单位,每个线程有独立的运行栈和程序计数器
4.JAVA中贤臣共分为两类:守护线程和用户线程(GC垃圾回收就是典型的守护线程)

二、代码完成继承Thread的方式创建分线程,并遍历100以内的自然数

三、代码完成实现Runnable接口的方法创建分线程,并且遍历100以内的自然数

四、对比两种创建方式

1.不同点:extends只能继承一个方法,如果继承Thread方法可能有一定的局限性,而实现Runnable可以实现多个接口,没有影响
2.相同点:都是要重写run方法和创建实现类对象

五、Thread中常用的方法测试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.sleep():让当前线程睡眠,在制定的时间内,线程是阻塞的状态.
9.isAlive():判断当前线程是否还存活

线程的优先级:

1.
MAX_PRIORITY:10
MIN_PRORITY:1
NORM+PRIORITY:5
2.如何获取和设置当前线程的优先级:
getPriority():获取线程的优先级
setPriority(int p)设置线程的优先级
说明:高优先级的线程抢占低优先级的线程CPU的执行权,但是只从概率上讲,高优先级的线程高概率的情况下被执行.
并不意味着只有当高优先级的线程执行完以后,低优先级的线程才执行

六、三个窗口一共卖100张票

实现Runnable接口

继承Thread方法

补充:线程的分类

java中的线程分为两类:一种是守护线程,一种是用户线程(main方法)
1.它们几乎每个方面的都是相同的,唯一的区别就是判断JVM何时离开
2.守护线程是用来服务用户线程的,通过start()方法前调用Thread.setDameon(true)可以把一个用户线程编程一个守护线程
3.java垃圾回收就是一个典型的守护线程
4.若JVM都是守护线程,当前JVM将推出.

七、线程的生命周期

JDK中用Thread.state类定义了线程的几种状态
要想实现多线程,必须在主线程中创建新的线程对象,JAVA语言使用了Thread类及其子类的对象来表示线程在完整的生命周期需要经历五个阶段
新建:当一个Thread类或者子类的对象被声明创建时,新生的线程处于新建状态
就绪:处于新建的线程被start()后,将进入线程队列等待CPU时间片,此时它已经具备了运行的条件,只是还没有分配到CPU的资源
运行:当就绪的线程被调度并获得CPU资源,它就进入了运行状态.run()方法定义了线程的操作和功能
阻塞:在一些特殊情况下,被认为的挂起或者执行输入输出操作的时候,让出CPU并临时终止自己的执行,进入阻塞状态
死亡:线程完成了它的全部工作或线程被提前强制终止或出现异常导致

五、通过同步锁机制,解决线程安全问题

同步的方式:解决了线程安全问题—优势
操作同步代码时,只有一个线程参与其他线程等待,相当于是一个单线程的过程,效率过低—劣势

方式一:同步代码块

synchronized(同步监视器){
需要被同步的代码
}
说明:
1.操作共享数据的代码,即为需要被同步的代码
2.共享数据:多个线程共同该操作的变量,比如演唱会的门票
3.同步监视器:锁.任何一个类的对象都可以充当锁

要求:多个线程必须共用同一把锁.

class Windows1 implements Runnable {
    private static int ticket=100;
    public void run(){
        while(true){
            synchronized (this){// 也可以随机创建一个对象, 也可以windows1.class
                if(ticket>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}
public class Windows1Test{
    public static void main(String[] args) {
        Windows1 w1 = new Windows1();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();t2.start();t3.start();
    }
}

方式二:同步方法

如果操作共享数据代码完整的声明在一个方法中,那么可以将这个方法声明同步.
关于同步方法:
1.同步方法仍然涉及到同步监视器,只是不需要显式声明
2.非静态的同步方法,同步监视器都是this
静态的同步方法:监视器都是当前类本身 xxx.class

class window2 implements Runnable{
    private int ticket = 100;
    public void run(){
    while(true){
        show();
    }
    }
    private synchronized  void show(){//同步监视器:this
        if(ticket>0){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+ticket);
            ticket--;
        }
    }
}

public class Windows2Test {
    public static void main(String[] args) {
        window2 w1 = new window2();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();t2.start();t3.start();
    }
}

class Windows3 extends Thread{
    private static int ticket=100;
    public void run(){
        while(true){
            show();
        }
    }
    private static synchronized void show(){//同步监视器 Windows4.class
//        private synchronized void show(){//同步监视器 w1,w2,w3
        if(ticket>0){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+ticket);
            ticket--;
        }
    }
}
public class Windows2TestThread {
    public static void main(String[] args) {
        Windows3 w1 = new Windows3();
        Windows3 w2 = new Windows3();
        Windows3 w3 = new Windows3();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w2.start();
        w3.start();
    }
}

一个线程安全的懒汉式

class Bank {
    private Bank(){

    }
    private static Bank Instance = null;
    private static Bank getInstance(){
        //方式一:效率较差
//        synchronized (Bank.class){
//        if(Instance==null){
//            Instance = new Bank();
//        }
//        return Instance;
//    }
        //方式二:效率更好
    if(Instance == null){
        synchronized (Bank.class){
            if(Instance == null){
                Instance = new Bank();
            }
        }
    }
    return Instance;
    }
}

六、死锁

1.互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
2.请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
3.不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
4.环路等待条件：在发生死锁时，必然存在一个进程–资源的环形链。

public class ThreadTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread(){
            public void run(){
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }){}.start();
    }
}

七、LOCK锁 JDK5.0新增

synchronized和lock锁的区别:
1.都可以解决线程安全问题
2.synchronized 机制在执行完相应的同步代码以后,会自动释放同步监视器,lock需要手动启动同步(lock()),同时结束同步也需要手动的实现(unlock())
优先顺序: lock>同步代码块>同步方法

class Windows4 implements Runnable{
    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();//里面有参数true
    @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 Windows3TestLock {
    public static void main(String[] args) {
        Windows4 w1 = new Windows4();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();t2.start();t3.start();
    }
}

八、多线程的通信

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

sleep和wait的方法异同:

1.相同点:一旦执行此方法,线程都将进入阻塞状态
2.不同点:1)两个方法声明的位置不同:Thread类中声明的sleep(),Object()中声明的wait()
2)调用要求不同:sleep()可以在任何场景下调用,而wait方法只能在同步方法或者同步代码块中调用
3)是否释放同步监视器:sleep()不释放同步监视器,wait()释放同步监视器

class Number implements Runnable{
    private int number=1;
    @Override
    public void run() {
        while(true){
            synchronized(this){
                notify();
                if(number <=100){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                }else{
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class Test1Number {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
}

九、练习题

/*
    线程通信的应用:
    生产者(Productor)将产品交给店员(clerk),而消费者(Customer)从店员处取走产品,
    店员一次只能持有固定数量的产品(20)如果生产者想生产更多,那么就会被停止,如果店中没有产品了,店员会告诉消费者等一下,然后接着生产产品
 */
class Clerk{
    private int ProductNum = 0;
    //生产
    public synchronized void produce(){
        if(ProductNum < 20){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ProductNum++;
            System.out.println(Thread.currentThread().getName()+"生产第"+ProductNum+"个产品");
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费
    public synchronized  void consume(){
        if(ProductNum >0){
            try {
                Thread.sleep(80);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"消费第"+ProductNum+"个产品");
            ProductNum--;
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer extends Thread{
    private Clerk clerk;
    public Producer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println("生产者开始生产");
        while(true){
            clerk.produce();
        }
    }
}
class Consumer extends Thread{
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println("消费者开始消费");
        while(true){
            clerk.consume();
        }
    }
}
public class Test2ceshi {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");
        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        c1.start();
        p1.start();
    }
}

十、实现Callable接口

如何理解Callable接口的方式创建多线程比实现 Runnable接口创建多线程的方式强大:

1.call()可以有返回值
2.call()抛出异常,被外面的操作捕获,获取异常的信息
3.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 ThreadCallable {
    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方法的返回值
            Object obj = futureTask.get();
            System.out.println("总和为:"+obj);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

十一、线程池的基本概念

好处:
1.提高响应速度(减少了创建新线程的时间)
2.降低资源消耗(可以重复利用线程池中的线程,不需要每次都创建)
3.便于线程管理
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时,最多保持多长时间会终止

class NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class NumberThread1 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) {
        //1.提供指定线程数量的线程池 ExecutorService 是一个接口
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());//ThreadPoolExecutor
        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();
//         ((ThreadPoolExecutor) service).setMaximumPoolSize();
        //2.执行指定的线程的操作,需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread()); //适合Runnable
        service.execute(new NumberThread1());
//      service.submit(Callable callable)  适合callable
        //3.关闭连接池
        service.shutdown();

    }
}