学习日记46--java学习--多线程

什么是线程
- 线程是程序执行的一条路径, 一个进程中可以包含多条线程
- 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
多线程并行和并发的区别
- 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
- 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
- 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
- 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。
- 一个处理器（cpu）在某一个时间点上永远都只能是一个线程。就单核心cpu而言某个时间点只能是一个线程在运行，所谓的多线程是通过调度获取cpu的时间片实现的，多线程是 cpu一下子干这件事，时间片到了就干另一件事。由于cpu计算速度很快很快所以看起来就像几件事情在同时进行。
Java程序运行原理
- Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。
- JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

多线程实现

继承Thread

public static void main(String[] args) {
        MyThread mt = new MyThread();       //4,创建Thread类的子类对象
        mt.start();                         //5,开启线程

        for(int i = 0; i < 1000; i++) {
            System.out.println("bb");
        }
    }

}

class MyThread extends Thread {             //1,继承Thread
    public void run() {                     //2,重写run方法
        for(int i = 0; i < 1000; i++) {     //3,将要执行的代码写在run方法中
            System.out.println("aaaaaaaaaaaa");
        }
    }

实现Runnable

public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();   //4,创建Runnable的子类对象
        //Runnable target = mr; mr = 0x0011
        Thread t = new Thread(mr);          //5,将其当作参数传递给Thread的构造函数
        t.start();                          //6,开启线程

        for(int i = 0; i < 1000; i++) {
            System.out.println("bb");
        }
    }

}

class MyRunnable implements Runnable {      //1,定义一个类实现Runnable

    @Override
    public void run() {                     //2,重写run方法
        for(int i = 0; i < 1000; i++) {     //3,将要执行的代码写在run方法中
            System.out.println("aaaaaaaaaaaa");
        }
    }

两种方式的区别)
- 查看源码的区别:
  - a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
  - b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
- 继承Thread
  - 好处是:可以直接使用Thread类中的方法,代码简单
  - 弊端是:如果已经有了父类,就不能用这种方法
- 实现Runnable接口
  - 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
  - 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
多线程(获取名字和设置名字)
- 1.获取名字
- 通过getName()方法获取线程对象的名字
- 2.设置名字
- 通过构造函数可以传入String类型的名字

多线程(获取当前线程的对象)

Thread.currentThread(), 主线程也可以获取

new Thread(new Runnable() {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "...aaaaaaaaaaaaaaaaaaaaa");
        }
    }
}).start();

new Thread(new Runnable() {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "...bb");
        }
    }
}).start();
Thread.currentThread().setName("我是主线程");                    //获取主函数线程的引用,并改名字
System.out.println(Thread.currentThread().getName());       //获取主函数线程的引用,并获取名字

多线程(休眠线程)

Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000

new Thread() {
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}.start();

new Thread() {
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(getName() + "...bb");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}.start();

多线程(守护线程)
- setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出。
- 守护线程与普通线程的唯一区别是：https://blog.csdn.net/u012891504/article/details/52189435
  理解一 : 守护线程就是main同生共死，当main退出，它将终止，而普通线程是在任务执行结束才停止。理解二：用户线程：Java虚拟机在它所有非守护线程已经离开后自动离开。守护线程则是用来服务用户线程的，如果没有其他用户线程在运行，那么就没有可服务对象，也就没有理由继续下去。例如：我们所熟悉的Java垃圾回收线程就是一个典型的守护线程，当我们的程序中不再有任何运行中的Thread，程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是Java虚拟机上仅剩的线程时，Java虚拟机会自动离开。
多线程(加入线程)，（插队）
多线程(礼让线程) ，（让位）
设置线程的优先级，分配优先级
同步代码块
- 1.什么情况下需要同步
- 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
- 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
- 2.同步代码块
- 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
- 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

单例设计模式
（1）恶汉式:内部先创建对象，可能会造成内存浪费

class Singleton {
    //1,私有构造方法,其他类不能访问该构造方法了
    private Singleton(){}
    //2,创建本类对象
    private static Singleton s = new Singleton();
    //3,对外提供公共的访问方法
    public static Singleton getInstance() {             //获取实例
        return s;
    }
}

（2）懒汉式:内部先声明引用，不创建对象（开发时不用）

class Singleton {
    //1,私有构造方法,其他类不能访问该构造方法了
    private Singleton(){}
    //2,声明一个引用
    private static Singleton s ;
    //3,对外提供公共的访问方法
    public static Singleton getInstance() {             //获取实例
        if(s == null) {                  //判断，如果s是null就允许创建对象，不是null不创建
            //多线程访问时会有安全问题，线程1等待,线程2等待
            s = new Singleton();
        }

        return s;
    }
}

（3）恶汉式和懒汉式的区别
1，恶汉式是空间换时间，懒汉式是时间换空间（不推荐）
2，在多线程访问时，恶汉式不会创建多个对象，而懒汉式可能会创建多个对象
3，无判断语句直接返回对象是恶汉式，有判断语句是懒汉式

Runtime类
Runtime是一个单例类。
Runtime.getRuntime()返回与当前Java应用程序关联的运行时对象。是单例方法，必须针对当前的运行时对象进行调用。例：exec(String command) —>
在单独的进程中执行指定的字符串命令。
计时器类Timer
Timer t = new Timer();
//在指定时间安排指定任务
t.schedule(new MyTimerTask(), new Date(118, 8, 1, 10, 21, 50),3000);
//第一个参数,是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间再重复执行
线程通信
1.什么时候需要通信
- 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
- 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
- 2.怎么通信
- 如果希望线程等待, 就调用wait()
- 如果希望唤醒等待的线程, 就调用notify();
- 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用
三个或三个以上间的线程通信
- 多个线程通信的问题
- notify()方法是随机唤醒一个线程
- notifyAll()方法是唤醒所有线程
- JDK5之前无法唤醒指定的一个线程
- 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件（二个线程通信用的是if循环）
1，在同步代码块中,用哪个对象锁,就用哪个对象调用wait方法
2，为什么wait方法和notify方法定义在Object这类中?
因为锁对象可以是任意对象,Object是所有的类的基类,所以wait方法和notify方法需要定义在Object这个类中
3，sleep方法和wait方法的区别?
(a) sleep方法必须传入参数,参数就是时间,时间到了自动醒来
wait方法可以传入参数也可以不传入参数,传入参数就是在参数的时间结束后等待,不传入参数就是直接等待
(b) sleep方法在同步函数或同步代码块中,不释放锁,睡着了也仍锁住
wait方法在同步函数或者同步代码块中,释放锁
补充：锁就是cpu执行权

ReentrantLock类重入锁
1.同步
* 使用ReentrantLock类的lock()和unlock()方法进行同步
2.通信
* 使用ReentrantLock类的newCondition()方法可以获取Condition对象，从而可操作指定线程
* 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
* 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了
3.实例

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

public class Demo3_ReentrantLock {

    /**
     * @param args
     */
    public static void main(String[] args) {
        final Printer3 p = new Printer3();

        new Thread() {
            public void run() {
                while(true) {
                    try {
                        p.print1();
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread() {
            public void run() {
                while(true) {
                    try {
                        p.print2();
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread() {
            public void run() {
                while(true) {
                    try {
                        p.print3();
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

}

class Printer3 {
    private ReentrantLock r = new ReentrantLock();
    private Condition c1 = r.newCondition();
    private Condition c2 = r.newCondition();
    private Condition c3 = r.newCondition();

    private int flag = 1;
    public void print1() throws InterruptedException {                          
        r.lock();                               //获取锁
            if(flag != 1) {
                c1.await();
            }
            System.out.print("H");
            System.out.print("e");
            System.out.print("l");
            System.out.print("l");
            System.out.print("o");
            System.out.print("\r\n");
            flag = 2;
            //this.notify();                        //随机唤醒单个等待的线程
            c2.signal();
        r.unlock();                             //释放锁
    }

    public void print2() throws InterruptedException {
        r.lock();
            if(flag != 2) {
                c2.await();
            }
            System.out.print("e");
            System.out.print("v");
            System.out.print("e");
            System.out.print("r");
            System.out.print("y");
            System.out.print("\r\n");
            flag = 3;
            //this.notify();
            c3.signal();
        r.unlock();
    }

    public void print3() throws InterruptedException {
        r.lock();
            if(flag != 3) {
                c3.await();
            }
            System.out.print("d");
            System.out.print("a");
            System.out.print("y");
            System.out.print("\r\n");
            flag = 1;
            c1.signal();
        r.unlock();
    }
}

线程组概述
- Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
- 默认情况下，所有的线程都属于主线程组。
  - public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
  - public final String getName()//通过线程组对象获取他组的名字
- 我们也可以给线程设置分组
  - ThreadGroup(String name) 创建线程组对象并给其赋值名字
  - 创建线程对象
  - Thread(ThreadGroup?group, Runnable?target, String?name)
  - 作用：方便设置整组的优先级或者守护线程
线程的5个状态:新建—start()—>就绪状态（有执行权没有执行资格）—-系统分配—>运行（有执行资格）[—–sleep(),wait()—>阻塞（没有执行资格没有执行权）—–>就绪状态—>运行]—-run(),stop()—>死亡（变成垃圾）
线程池的概述和使用
- A:线程池概述
- 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池
- B:内置线程池的使用概述
- JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
  - public static ExecutorService newFixedThreadPool(int nThreads)
  - public static ExecutorService newSingleThreadExecutor()
  - 这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
    Future<?> submit(Runnable task)
    <T> Future<T> submit(Callable<T> task)
Callable接口实现多线程程序实现
- 好处：
  - 可以有返回值
  - 可以抛出异常
- 弊端：
  - 代码比较复杂，所以一般不用

学习日记46--java学习--多线程

猜你喜欢