Java学习笔记(四):创建多线程的四种方式 & 同步机制

基本概念

程序(program)

一段静态的代码

进程(process)

  • 程序的一次执行过程,或者是正在运行的程序,如:运行中的QQ

  • 程序是静态的,进程是动态的

  • 进程是资源分配的单位

线程(thread)

  • 进程可细分为线程,是一个程序内部的一条执行路径

  • 若一个进程同一时间并行执行多个线程,就是支持多线程的

  • 生命周期:新建–就绪–执行–(阻塞)–死亡

多线程(multi-thread)

优点

  • 提高应用程序的响应,对图形化界面更有意义,增强用户体验
  • 提高CPU的利用率
  • 改善程序结构

应用场合

  • 程序需要同时执行两个或多个任务
  • 程序需要实现一些需要等待的任务时,比如:用户输入,文件读写,网络操作,搜索等
  • 需要一些后台运行的程序时

生成线程

  1. 通过继承:extends Thread
class MyThread extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0)
            System.out.println(i);
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        //调用start()方法:1⃣ 启动当前的线程 2⃣ 调用当前线程的run()方法
        mt.start();

        //如下操作仍是在main线程中执行的
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0)
                System.out.println(i + "******  main()    ********");
        }

    }
}
  1. 通过接口:implements Runnable
class MThread 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 ThreadTest2 {
    public static void main(String[] args) {
        MThread mThread = new MThread();
        Thread t1 = new Thread(mThread);
        t1.start();

        Thread t2 = new Thread(mThread);
        t2.start();
    }
}

说明:

  1. 在开发中,优先选择实现接口的方式来创建线程。因为实现的方式没有类的单继承性的局限性;实现的方式更适合来处理多个线程有共享数据的情况。
  2. 两种方式的关系:public class Thread implements Runnable{ }
  3. 相同点:都需要重写run()

Java同步机制来解决线程安全的问题

死锁

理解:

  • 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
  • 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续
  • 使用同步时,避免出现死锁

同步机制

同步代码块

synchronized (同步监视器){
  //需要被同步的代码
}

说明:

  • 操作共享数据的代码,即为需要同步的代码
  • 共享数据:多个线程共同操作的变量
  • 同步监视器:锁。任何一个类的对象,都可以充当锁,但是多个线程必须要共用同一把锁
package Thread;

//synchronized(同步监视器){
//      需要被同步的代码
//}

class Window3 implements Runnable{
    private int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while(true){
            //this也可以作为对象
            synchronized(obj){
                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

同步方法

public synchronized void show(){
  // 需要被同步的代码
}

说明:

  • 同步方法仍然涉及到同步监视器,只是不需要显式的声明
  • 非static的同步方法,同步监视器为this
  • static的同步方法,同步监视器为当前类本身

Lock(JDK5.0增加)

实现ReentrantLock类,调用lock()和unlock()

synchronized和Lock的异同点

相同点:二者都可以解决线程安全的问题

不同点:

  1. synchronized机制在执行完相应的同步代码后,自动释放同步监视器
  2. Lock需要手动地启动同步lock(),同时结束同步也需要手动实现unlock()
package Thread;

//解决线程安全问题方式三:Lock

import java.util.concurrent.locks.ReentrantLock;

class WindowLock implements Runnable{
    private int ticket = 100;

    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {


        while(true){
            try{
                //2.调用锁定方法lock()
                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 {
                //3.调用解锁方法unlock()
                lock.unlock();
            }

        }
    }
}

public class LockTest1 {
    public static void main(String[] args) {
        WindowLock wl = new WindowLock();

        Thread t1 =new Thread(wl);
        Thread t2 =new Thread(wl);
        Thread t3 =new Thread(wl);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

优先使用的顺序:

Lock–同步代码块–同步方法

线程通信

案例:使用两个线程打印1-100,交替打印

涉及到的方法:wait() & notify() & notifyAll()

  • wait():一旦执行此方法,当前线程就会进入阻塞状态并释放同步监视器
  • notify():一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait,就会唤醒优先级高的
  • notifyAll():一旦执行此方法,就会唤醒所有被wait的线程

说明:

  • wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中
  • wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则,会出现IllegalManitorStateException
  • wait(),notify(),notifyAll()三个方法都定义在java.lang.Object类中

sleep() & wait()

相同点:一旦执行方法,都可以使当前的线程进入阻塞状态

不同点:

  1. 声明的位置不同,Thread类声明sleep(),Object类声明wait()
  2. 调用范围不同,sleep()可以在任何需要的场景下调用,wait()必须在同步代码块或同步方法中
  3. sleep()不释放同步监视器,wait()释放同步监视器

创建线程的其他方式

实现Callable接口(JDK5增加)

如何理解Callable接口比Runnable接口强大?

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

线程池

思路:

提前创建好多个线程放入线程池中,使用时直接获取,使用完放回池中,可以避免频繁地创建销毁,实现重复利用

优点:

  1. 提高响应速度(减少创建新线程的时间)
  2. 降低资源消耗
  3. 便于线程管理

一些参数:
corePoolSize:核心池的大小

maximumPoolSize:最大线程数

keepAliveTime:最多保持时间

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页