多线程学习

最新推荐文章于 2022-04-13 17:00:02 发布
最新推荐文章于 2022-04-13 17:00:02 发布
阅读量134 收藏
点赞数
分类专栏： 学习 Java 集合 文章标签： Java 多线程
Java 同时被 3 个专栏收录
11 篇文章 0 订阅
订阅专栏
学习
9 篇文章 0 订阅
订阅专栏
集合
3 篇文章 0 订阅
订阅专栏

多线程

一. 多线程是什么? 为什么要使用多线程

  介绍多线程之前要介绍线程，介绍线程则离不开进程。
  首先 进程 ：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元；
  线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个线程。
  多线程：一个进程中不只有一个线程。
  为什么要用多线程：
  ①、为了更好的利用cpu的资源，如果只有一个线程，则第二个任务必须等到第一个任务结束后才能进行，如果使用多线程则在主线程执行任务的同时可以执行其他任务，而不需要等待；
  ②、进程之间不能共享数据，线程可以；
  ③、系统创建进程需要为该进程重新分配系统资源，创建线程代价比较小；
  ④、Java语言内置了多线程功能支持，简化了java多线程编程。

二. 线程的生命周期

  • 新建 ：从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态；

  • 就绪 ：线程对象调用start()方法后，就处于就绪状态，等到JVM里的线程调度器的调度；

  • 运行 ：就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态。

  • 等待/阻塞/睡眠 ：在一个线程执行了sleep（睡眠）、suspend（挂起）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态。

  • 终止 ：run（）方法完成后或发生其他终止条件时就会切换到终止状态。

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

2.同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

3.其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

三. 创建线程的方法

  1. 继承Thread类：

        步骤：①、定义类继承Thread；
           ②、复写Thread类中的run方法；
              目的：将自定义代码存储在run方法，让线程运行
           ③、调用线程的start方法：
              该方法有两步：启动线程，调用run方法。


public class ThreadDemo1 {
    public static void main(String[] args) {  
        //创建两个线程
        ThreadDemo td = new ThreadDemo("zhangsan");
        ThreadDemo tt = new ThreadDemo("lisi");
        //执行多线程特有方法，如果使用td.run();也会执行，但会以单线程方式执行。
        td.start();
        tt.start();
        //主线程
        for (int i = 0; i < 5; i++) {
            System.out.println("main" + ":run" + i);
        }
    }
}
//继承Thread类
class ThreadDemo extends Thread{
    //设置线程名称
    ThreadDemo(String name){
        super(name);
    }
    //重写run方法。
    public void run(){
        for(int i = 0; i < 5; i++){
        System.out.println(this.getName() + "：run" + i);　　//currentThread()  获取当前线程对象（静态）。  getName（） 获取线程名称。
        }
    }
}

  2. 实现Runnable接口：

      接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。
实现步骤： ①、定义类实现Runnable接口
　　　　　 ②、覆盖Runnable接口中的run方法，将线程要运行的代码放在该run方法中。
　　　　　 ③、通过Thread类建立线程对象。
　　　　　 ④、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
      自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确run方法所属对象
     ⑤、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。


public class RunnableDemo {
    public static void main(String[] args) {
        RunTest rt = new RunTest();
        //建立线程对象
        Thread t1 = new Thread(rt);
        Thread t2 = new Thread(rt);
        //开启线程并调用run方法。
        t1.start();
        t2.start();
    }
}

//定义类实现Runnable接口
class RunTest implements Runnable{
    private int tick = 10;
    //覆盖Runnable接口中的run方法,并将线程要运行的代码放在该run方法中。
    public void run(){
        while (true) {
            if(tick > 0){
                System.out.println(Thread.currentThread().getName() + "..." + tick--);
            }
        }
    }
}

  3. 通过Callable和Future创建线程：

     实现步骤：
     ①、创建Callable接口的实现类，并实现call()方法，改方法将作为线程执行体，且具有返回值。
     ②、创建Callable实现类的实例，使用FutrueTask类进行包装Callable对象，FutureTask对象封装了Callable对象的call()方法的返回值
     ③、使用FutureTask对象作为Thread对象启动新线程。
     ④、调用FutureTask对象的get（）方法获取子线程执行结束后的返回值。


public class CallableFutrueTest {
    public static void main(String[] args) {
        CallableTest ct = new CallableTest();                        //创建对象
        FutureTask<Integer> ft = new FutureTask<Integer>(ct);        //使用FutureTask包装CallableTest对象
        for(int i = 0; i < 100; i++){
            //输出主线程
            System.out.println(Thread.currentThread().getName() + "主线程的i为：" + i);
            //当主线程执行第30次之后开启子线程
            if(i == 30){        
                Thread td = new Thread(ft,"子线程");
                td.start();
            }
        }
        //获取并输出子线程call()方法的返回值
        try {
            System.out.println("子线程的返回值为" + ft.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class CallableTest implements Callable<Integer>{
    //复写call() 方法，call()方法具有返回值
    public Integer call() throws Exception {
        int i = 0;
        for( ; i<100; i++){
            System.out.println(Thread.currentThread().getName() + "的变量值为：" + i);
        }
        return i;
    }
}

  4. 使用线程池来创建线程

      为什么用线程池?

        1.创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处-理效率
        2.线程并发数量过多，抢占系统资源从而导致阻塞
        3.对线程进行一些简单的管理

  在Java中，线程池的概念是Executor这个接口，具体实现为ThreadPoolExecutor类，学习Java中的线程池，就可以直接学习他了对线程池的配置，就是对ThreadPoolExecutor构造函数的参数的配置

    4.1 ThreadPoolExecutor提供了四个构造函数

//五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)

//六个参数的构造函数-1
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)

//六个参数的构造函数-2
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler)

//七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

下面来解释下各个参数：

  • int corePoolSize：该线程池中核心线程数最大值

  核心线程：线程池新建线程的时候，如果当前线程总数小于corePoolSize，则新建的是核心线程，如果超过corePoolSize，则新建的是非核心线程核心线程默认情况下会一直存活在线程池中，即使这个核心线程啥也不干(闲置状态)。
如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true，那么核心线程如果不干活(闲置状态)的话，超过一定时间(时长下面参数决定)，就会被销毁掉。

  • int maximumPoolSize： 该线程池中线程总数最大值

  线程总数 = 核心线程数 + 非核心线程数。

  • long keepAliveTime：该线程池中非核心线程闲置超时时长

  一个非核心线程，如果不干活(闲置状态)的时长超过这个参数所设定的时长，就会被销毁掉，如果设置allowCoreThreadTimeOut = true，则会作用于核心线程。

  • TimeUnit unit：keepAliveTime的单位

  TimeUnit是一个枚举类型，其包括：
  NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
  MICROSECONDS ： 1微秒 = 1毫秒 / 1000
  MILLISECONDS ： 1毫秒 = 1秒 /1000
  SECONDS ： 秒
  MINUTES ： 分
  HOURS ： 小时
  DAYS ： 天

  • BlockingQueue workQueue：该线程池中的任务队列：维护着等待执行的Runnable对象

  当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务。
常用的workQueue类型：

  • SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，

  maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大

  • LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize

  • ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误

  • DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

  • ThreadFactory threadFactory：创建线程的方式，这是一个接口，你new他的时候需要实现他的Thread newThread(Runnable r)方法，一般用不上。

  • RejectedExecutionHandler handler：这玩意儿就是抛出异常专用的，比如上面提到的两个错误发生了，就会由这个handler抛出异常，根本用不上。

    4.2 向ThreadPoolExecutor添加任务

        我们怎么知道new一个ThreadPoolExecutor，大概知道各个参数是干嘛的，可是我new完了，怎么向线程池提交一个要执行的任务啊？

ThreadPoolExecutor.execute(Runnable command)

        通过ThreadPoolExecutor.execute(Runnable command)方法即可向线程池内添加一个任务。

    4.3 ThreadPoolExecutor的策略

        这里给总结一下，当一个任务被添加进线程池时，执行策略：

        1.线程数量未达到corePoolSize，则新建一个线程(核心线程)执行任务
        2.线程数量达到了corePools，则将任务移入队列等待
        3.队列已满，新建线程(非核心线程)执行任务
        4.队列已满，总线程数又达到了maximumPoolSize，就会由(RejectedExecutionHandler)抛出异常

    4.4 常见四种线程池：

        如果你不想自己写一个线程池，Java通过Executors提供了四种线程池，这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的。

     4.4.1 可缓存线程池CachedThreadPool()

源码：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

根据源码可以看出：

  1. 这种线程池内部没有核心线程，线程的数量是有没限制的。
  2. 在创建任务时，若有空闲的线程时则复用空闲的线程，若没有则新建线程。
  3. 没有工作的线程（闲置状态）在超过了60S还不做事，就会销毁。

创建方法：

ExecutorService mCachedThreadPool = Executors.newCachedThreadPool();

用法：

private void startDownload(final ProgressBar progressBar, final int i) {
        mCachedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                int p = 0;
                progressBar.setMax(10);//每个下载任务10秒
                while (p < 10) {
                    p++;
                    progressBar.setProgress(p);
                    Bundle bundle = new Bundle();
                    Message message = new Message();
                    bundle.putInt("p", p);
                    //把当前线程的名字用handler让textview显示出来
                    bundle.putString("ThreadName", Thread.currentThread().getName());
                    message.what = i;
                    message.setData(bundle);
                    mHandler.sendMessage(message);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }
     4.4.2 FixedThreadPool 定长线程池

源码:

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

根据源码可以看出：

  1. 该线程池的最大线程数等于核心线程数，所以在默认情况下，该线程池的线程不会因为闲置状态超时而被销毁。
  2. 如果当前线程数小于核心线程数，并且也有闲置线程的时候提交了任务，这时也不会去复用之前的闲置线程，会创建新的线程去执行任务。如果当前执行任务数大于了核心线程数，大于的部分就会进入队列等待。等着有闲置的线程来执行这个任务。

创建方法：

//nThreads => 最大线程数即maximumPoolSize
ExecutorService mFixedThreadPool= Executors.newFixedThreadPool(int nThreads);

//threadFactory => 创建线程的方法，用得少
ExecutorService mFixedThreadPool= Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

用法：

private void startDownload(final ProgressBar progressBar, final int i) {
        mFixedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
               //....逻辑代码自己控制
            }
        });
    }
     4.4.3 SingleThreadPool

源码：

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

根据源码可以看出：

  1. 有且仅有一个工作线程执行任务
  2. 所有任务按照指定顺序执行，即遵循队列的入队出队规则
    创建方法：
ExecutorService mSingleThreadPool = Executors.newSingleThreadPool();

用法同上。

     4.4.4 ScheduledThreadPool

源码：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}

根据源码可以看出：
DEFAULT_KEEPALIVE_MILLIS就是默认10L，这里就是10秒。这个线程池有点像是吧CachedThreadPool和FixedThreadPool 结合了一下。

  1. 不仅设置了核心线程数，最大线程数也是Integer.MAX_VALUE。
  2. 这个线程池是上述4个中为唯一个有延迟执行和周期执行任务的线程池。

创建：

//nThreads => 最大线程数即maximumPoolSize
ExecutorService mScheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);

一般的执行任务方法和上面的都大同小异，我们主要看看延时执行任务和周期执行任务的方法。

//表示在3秒之后开始执行我们的任务。
mScheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
            //....
            }
        }, 3, TimeUnit.SECONDS);

//延迟3秒后执行任务，从开始执行任务这个时候开始计时，每7秒执行一次不管执行任务需要多长的时间。 
mScheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
             //....
            }
        },3, 7, TimeUnit.SECONDS);

/**延迟3秒后执行任务，从任务完成时这个时候开始计时，7秒后再执行，
*再等完成后计时7秒再执行也就是说这里的循环执行任务的时间点是
*从上一个任务完成的时候。
*/
mScheduledThreadPool.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
             //....
            }
        },3, 7, TimeUnit.SECONDS);

四. 继承Thread类和实现Runnable接口、实现Callable接口的区别

  继承Thread：线程代码存放在Thread子类run方法中。
    优势：编写简单，可直接用this.getname（）获取当前线程，不必使用Thread.currentThread（）方法。
    劣势：已经继承了Thread类，无法再继承其他类。

  实现Runnable接口：线程代码存放在接口的子类的run方法中。
    优势：避免了单继承的局限性、多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
    劣势：比较复杂、访问线程必须使用Thread.currentThread（）方法、无返回值。

  实现Callable接口：
    优势：有返回值、避免了单继承的局限性、多个线程可以共享一个target对象，非常适合多线程处理同一份资源的情形。
    劣势：比较复杂、访问线程必须使用Thread.currentThread（）方法

  建议使用实现接口的方式创建多线程

五. 线程状态管理

  1. 线程睡眠 — sleep

      线程睡眠的原因：线程执行的太快，或需要强制执行到下一个线程。

      线程睡眠的方法（两个）：sleep（long millis）在指定的毫秒数内让正在执行的线程休眠。

      sleep（long millis，int nanos）在指定的毫秒数加指定的纳秒数内让正在执行的线程休眠。

\线程睡眠的代码演示：


public class SynTest {
    public static void main(String[] args) {
        new Thread(new CountDown(),"倒计时").start();
    }
}

class CountDown implements Runnable{
    int time = 10;
    public void run() {
        while (true) {
            if(time>=0){
                System.out.println(Thread.currentThread().getName() + ":" + time--);
                try {
                    Thread.sleep(1000);                                                    //睡眠时间为1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

每隔一秒则会打印一次，打印结果为：

倒计时:10
倒计时:9
倒计时:8
倒计时:7
倒计时:6
倒计时:5
倒计时:4
倒计时:3
倒计时:2
倒计时:1
倒计时:0

  扩展：Java线程调度是Java多线程的核心，只有良好的调度，才能充分发挥系统的性能，提高程序的执行效率。但是不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。因为使用sleep方法之后，线程是进入阻塞状态的，只有当睡眠的时间结束，才会重新进入到就绪状态，而就绪状态进入到运行状态，是由系统控制的，我们不可能精准的去干涉它，所以如果调用Thread.sleep(1000)使得线程睡眠1秒，可能结果会大于1秒。

  2. 线程让步 — yield

  该方法和sleep方法类似，也是Thread类提供的一个静态方法，可以让正在执行的线程暂停，但是不会进入阻塞状态，而是直接进入就绪状态。相当于只是将当前线程暂停一下，然后重新进入就绪的线程池中，让线程调度器重新调度一次。也会出现某个线程调用yield方法后暂停，但之后调度器又将其调度出来重新进入到运行状态。


public class SynTest {
    public static void main(String[] args) {
        yieldDemo ms = new yieldDemo();
        Thread t1 = new Thread(ms,"张三吃完还剩");
        Thread t2 = new Thread(ms,"李四吃完还剩");
        Thread t3 = new Thread(ms,"王五吃完还剩");
        t1.start();
        t2.start();
        t3.start();
    }
}
class yieldDemo implements Runnable{
    int count = 20;
    public void run() {
        while (true) {
                if(count>0){
                    System.out.println(Thread.currentThread().getName() + count-- + "个瓜");
                    if(count % 2 == 0){
                        Thread.yield();　　　　　　　　　　　　　　　　　　//线程让步
                    }
            }
        }
    }
}

sleep和yield的区别：

  ①、sleep方法声明抛出InterruptedException，调用该方法需要捕获该异常。yield没有声明异常，也无需捕获。

  ②、sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield方法调用后 ，是直接进入就绪状态。

  3. 线程合并 — join

    当B线程执行到了A线程的.join（）方法时，B线程就会等待，等A线程都执行完毕，B线程才会执行。join可以用来临时加入线程执行。

以下为代码演示：


public static void main(String[] args) throws InterruptedException {    
        yieldDemo ms = new yieldDemo();
        Thread t1 = new Thread(ms,"张三吃完还剩");
        Thread t2 = new Thread(ms,"李四吃完还剩");
        Thread t3 = new Thread(ms,"王五吃完还剩");
        t1.start();
        t1.join();
        
        t2.start();
        t3.start();
        System.out.println( "主线程");
    }

  4. 停止线程

    原stop方法因有缺陷已经停用了，那么现在改如何停止线程？现在分享一种，就是让run方法结束。

    开启多线程运行，运行的代码通常是循环结构，只要控制住循环，就可以让run方法结束，也就是线程结束。

具体代码如下：


public class StopThread {

    public static void main(String[] args) {
        int num = 0;
        StopTh st = new StopTh();
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.start();
        t2.start();
        //设置主线程执行50次，执行结束之后停止线程
        while (true) {
            if(num++ == 50){                        
                st.flagChange();
                break;
            }
            System.out.println(Thread.currentThread().getName() + "..." + num);
        }
    }
}

class StopTh implements Runnable{

    private boolean flag = true;
    public void run() {
        while(flag){
            System.out.println(Thread.currentThread().getName() + "stop run" );
        }
    }
    public void flagChange(){
        flag = false;
    }
}

  特殊情况：当线程处于了冻结状态，就不会读取到标记，也就不会结束。当没有指定方法让冻结的线程回复到运行状态时，我们需要对冻结状态进行清除，也就是强制让线程恢复到运行状态中来，这样可就可以操作标记让线程结束。

  Thread类提供该方法： interrupt（）；（如果线程在调用Object类的wait（）、wait（long）、wait（long，int）方法，或者该类的join（）、join（long）、join（long、int）、sleep（long）或sleep（long、int）方法过程中受阻，则其中断状态将被清除，还将收到一个InterruptedException。）

  5. 设置优先级

  每个线程执行时都有一个优先级的属性，优先级高的线程可以获得较多的执行机会，而优先级低的线程则获得较少的执行机会。与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的也并非没机会执行。

Thread类中提供了优先级的三个常量，代码如下：

MAX_PRIORITY   = 10

MIN_PRIORITY   = 1

NORM_PRIORITY  = 5
ThreadDemo td = new ThreadDemo(); 
Thread t1 = new Thread(td,"张三"); t1.priority(9);　//设置优先级
 t1.start();//设置完毕

六. 线程同步与锁

  为什么要进行线程同步？

java允许多线程并发控制，当多个线程同时操作一个可共享资源变量时（如对其进行增删改查操作），会导致数据不准确，而且相互之间产生冲突。所以加入同步锁以避免该线程在没有完成操作前被其他线程调用，从而保证该变量的唯一性和准确性。

  不同步会发生的问题？

在介绍同步方法之前先演示一下当多个线程操作一个共享资源时可能会发生的错误，这里用的方法是让线程在执行时睡眠10毫秒，会导致多个线程去操作同一个资源变量：

public class SynTest {
    public static void main(String[] args) {
        //定义三个线程，
        MySyn ms = new MySyn();
        Thread t1 = new Thread(ms,"线程1输出：");
        Thread t2 = new Thread(ms,"线程2输出：");
        Thread t3 = new Thread(ms,"线程3输出：");
        t1.start();
        t2.start();
        t3.start();
    }
}

class MySyn implements Runnable{

    int tick = 10;                                        //共执行10次线程
    public void run() {
        while(true){
            if(tick>0){
                try {
                    Thread.sleep(10);                                //执行中让线程睡眠10毫秒，
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " " + tick--);
            }
        }
    }
}

输出结果用以下图片展示，可以看到我勾选的部分都发生了冲突数据：
在这里插入图片描述
同步方法1：

  同步函数：就是用synchronize关键字修饰的方法。因为每个java对象都有一个内置锁，当用synchronize关键字修饰方法时内置锁会保护整个方法，而在调用该方法之前，要先获得内置锁，否则就会处于阻塞状态。

代码演示：请将上方代码的第17行改为以下代码↓

   public synchronized void run() {

同步方法2：

  同步代码块：就是拥有synchronize关键字修饰的语句块，被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。

代码演示：将上方代码的run方法改成下方代码

public void run() {
        while(true){
            synchronized (this) {                        　　　　　　　　　//同步代码块
                if(tick>0){
                    try {
                        Thread.sleep(10);                                //执行中让线程睡眠10毫秒，
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " " + tick--);
                }
            }
        }
    }

加同步之后的输出数据为：

线程1输出： 10
线程2输出： 9
线程2输出： 8
线程2输出： 7
线程2输出： 6
线程2输出： 5
线程2输出： 4
线程3输出： 3
线程3输出： 2
线程3输出： 1

追加问题：如果同步函数被静态修饰之后，使用的锁是什么？静态方法中不能定义this！

静态内存是：内存中没有本类对象，但是一定有该类对应的字节码文件对象。 类名.class 该对象类型是Class。

所以静态的同步方法使用的锁是该方法所在类的字节码文件对象。 类名.class。代码如下：

public static mySyn(String name){
    synchronized (Xxx.class) {
        Xxx.name = name;
    }
}

--------------------------------以下是总结-----------------------------------

同步的前提：
　　1、必须要有两个或者两个以上的线程。
　　2、必须是多个线程使用同一个锁。
　　3、必须保证同步中只能有一个线程在运行。
　　4、只能同步方法，不能同步变量和类。
　　5、不必同步类中所有方法，类可以拥有同步和非同步的方法。
　　6、如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。
　　7、线程睡眠时，它所持的任何锁都不会释放。

好处：解决了多线程的安全问题。
　　弊端：多个线程需要判断，消耗资源，降低效率。

如何找问题？
　　1、明确哪些代码是多线程运行代码。
　　2、明确共享数据。
　　3、明确多线程运行代码中哪些语句是操作共享数据的。

七. 死锁

  进程A中包含资源A,进程B中包含资源B，A的下一步需要资源B，B的下一步需要资源A，所以它们就互相等待对方占有的资源释放，所以也就产生了一个循环等待死锁。

public class DeadLock {

    public static void main(String[] args) {
        Thread t1 = new Thread(new DeadLockTest(true));
        Thread t2 = new Thread(new DeadLockTest(false));
        t1.start();
        t2.start();
    }
}

class DeadLockTest implements Runnable{
    
    private boolean flag;
    static Object obj1 = new Object();
    static Object obj2 = new Object();
    public DeadLockTest(boolean flag) {
        this.flag = flag;
    }
    public void run(){
        if(flag){
            synchronized(obj1){
                System.out.println("if lock1");
                synchronized (obj2) {
                    System.out.println("if lock2");
                }
            }
        }else{
            synchronized (obj2) {
                System.out.println("else lock2");
                synchronized (obj1) {
                    System.out.println("else lock1");
                }
            }
        }
    }
 }

死锁形成的必要条件总结（都满足之后就会产生）：

  ①、互斥条件：资源不能被共享，只能被同一个进程使用；

  ②、请求与保持条件：已经得到资源的进程可以申请新的资源；

  ③、非剥夺条件：已经分配的资源不能从相应的进程中强制剥夺；

  ④、循环等待条件：系统中若干进程形成环路，该环路中每个进程都在等待相邻进程占用的资源。

八. 线程间的通信，等待唤醒机制

示例：

package com.hk.java.thread;

/**
 * 两个线程交替输出30以内的奇数偶数
 * 
 * @author 浪丶荡
 * 
 */
public class PrintOddEven implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i <= 31; i++) {
            if(i==31){//如果为31，强制结束程序
                System.exit(0);
            }
            //名为张三的线程负责输出偶数
            if (Thread.currentThread().getName().equals("张三")) {
                synchronized (this) {
                    if (i % 2 == 0) {
                        System.out.println("[ "
                                + Thread.currentThread().getName() + " ]打印偶数  "
                                + i);
                        notify();// 唤醒李四
                        try {
                            wait();// 当前线程（张三）放弃执行资格，等待，直到被其他线程唤醒
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            //名为李四的线程负责输出奇数
            if (Thread.currentThread().getName().equals("李四")) {
                synchronized (this) {
                    if (i % 2 == 1) {
                        System.out.println("[ "
                                + Thread.currentThread().getName() + " ]打印奇数  "
                                + i);
                        notify();//唤醒张三
                        try {
                            wait();// 当前线程（李四）放弃执行资格，等待，直到被其他线程唤醒
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }

        }
    }

}

测试类：

public static void main(String[] args) {
        PrintOddEven thereThread = new PrintOddEven();
        Thread thread = new Thread(thereThread);
        thread.setName("张三");
        thread.start();
        Thread threa = new Thread(thereThread);
        threa.setName("李四");
        threa.start();
}

结果：

[ 张三 ]打印偶数  0
[ 李四 ]打印奇数  1
[ 张三 ]打印偶数  2
[ 李四 ]打印奇数  3
[ 张三 ]打印偶数  4
[ 李四 ]打印奇数  5
[ 张三 ]打印偶数  6
[ 李四 ]打印奇数  7
[ 张三 ]打印偶数  8
[ 李四 ]打印奇数  9
[ 张三 ]打印偶数  10
[ 李四 ]打印奇数  11
[ 张三 ]打印偶数  12
[ 李四 ]打印奇数  13
[ 张三 ]打印偶数  14
[ 李四 ]打印奇数  15
[ 张三 ]打印偶数  16
[ 李四 ]打印奇数  17
[ 张三 ]打印偶数  18
[ 李四 ]打印奇数  19
[ 张三 ]打印偶数  20
[ 李四 ]打印奇数  21
[ 张三 ]打印偶数  22
[ 李四 ]打印奇数  23
[ 张三 ]打印偶数  24
[ 李四 ]打印奇数  25
[ 张三 ]打印偶数  26
[ 李四 ]打印奇数  27
[ 张三 ]打印偶数  28
[ 李四 ]打印奇数  29
[ 张三 ]打印偶数  30

分析：

notify：唤醒，唤醒对方，当线程池有多个线程出于等待状态时，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。

wait：此方法导致当前线程，将其自身放置在对象的等待集中，然后放弃此对象上的所有同步要求，也就是放弃执行权，释放占有的资源，直到被其他线程唤醒。

Gaby.kang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
labview多线程学习
09-03
多线程学习在LabVIEW中的核心概念： 1. **线程与并行执行**：线程是程序中的执行单元，一个进程可以包含一个或多个线程。在LabVIEW中，多线程允许同时执行多个任务，实现程序的并行处理，提高系统的响应速度和整体...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java 多线程学习
hua226的博客
04-13 2万+
Java 多线程 一、实现多线程 1.1 进程 进程：是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 1.3 多线程的实现方式 多线程的实现方案有两种： 继承Thread类 实现Runnable接口 方式1：继承Thread类 定义一个MyThread类继承Thread类 在M
多线程学习思维导图
weixin_44448094的博客
03-09 1565
Python 多线程学习
Herishwater的博客
05-10 3501
前言 在爬虫学习的过程中，一旦爬取的数量过大，很容易带来效率问题，为了能够快速爬取我们想要的内容。为此我们可以使用多线程或者多进程来处理。 多线程和多进程是不一样的！一个是 threading 库，一个是 multiprocessing 库。而多线程 threading 在 Python 里面被称作鸡肋的存在！关于 Python 多线程有这样一句名言——“Python下多线程是鸡肋，推荐使用多进程...
多线程学习完整流程图
大西瓜超帅
06-02 1290
多线程学习最完整流程图
java多线程学习（超详细吐血总结）
chenruijia170707的博客
11-11 2万+
声明：原文出处http://www.cnblogs.com/nsw2018/p/5822270.html，本人出于学习，收集干货，不作商业用途！以下原作者为林炳文Evankaka的原创作品。转载出处：http://blog.csdn.net/evankakahttp://blog.csdn.net/evankaka/article/details/44153709#t1  （java线程学习的入门...
C++多线程学习
weixin_43186817的博客
09-25 1738
先是一名搬运工，搬运C++多线程学习的文章，再好好学习，天天向上。 先是一个大佬博主的文章：关于C++进阶的，写得很是详细，膜拜啊！ C++进阶主题 其次，是该博主多线程的具体文章 C++多线程（一）thread类 c++ 多线线程（二）-mutex c++ 11 多线线程 future 接着是另一个博主写的多线程的文章，比较通俗易懂，大家懂得~ C++多线程类Thread（C++11 ...
Java技术——Java多线程学习
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
09-01 1万+
0.前言 转载请标明出处：http://blog.csdn.net/seu_calvin/article/details/52400927 学习多线程之前需要先了解以下几个概念。 进程：一般指一个程序运行时的实例，每个进程有自己独立的地址空间。一个进程无法直接访问另一个进程的数据。 线程：是CPU调度的最小单元，一个进程可以有很多线程，每条线程可以并行执行不同的任务。并且每个线程有独立的运...
Java多线程学习（基础篇）
nelson的博客
08-08 8173
第一节 1. java对线程的支持 java对线程的支持主要体现在Thread类以及Runable接口上，他们都位于java.lang包下，无论是Thread类还是Runable接口，它们都有public void run()方法，这个run方法为我们提供了线程实际工作时的代码，换句话说，我们的逻辑代码就可以写在run方法体中。 2. 线程的创建和启动 3. 线程的常用方法 ...
java多线程学习总结
peachli
05-03 3578
进程和线程的区别 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。 　　线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。 　　多进程是指操作系统能同时运行多个任务（程序）。 　　多线程是指在同一程
多线程学习笔记
03-18
多线程学习笔记，通过平时的学习所做的一些笔记，希望对广大同仁有所帮助
多线程学习资源
02-05
多线程概述，past，coolie，多线程控制，多线程验证码
java多线程学习
11-27
主要是结合课本和视频学习了一下java多线程的用法，这个专利适合于初学者学习多线程知识。
关于多线程学习总结
03-02
经常看到一些招聘上要求应聘者必须熟练掌握多线程，而对于我这个着实的菜鸟来说多线程这个概念虽然经常听到，但是在实际操作中用的比较少，而且了解的也比较浅显，所以乘着这休息的几天天好好的学习学习，补上这方面...
java多线程学习视频
10-30
Java多线程是一块重要的内容，李兴华讲解的Java是一个很好的资源
java多线程学习记录.rar
06-14
在本文中，我们将深入探讨Java多线程的相关知识点，这些内容来源于"java多线程学习记录"的文档。 1. **线程的概念与创建** - 线程是操作系统调度的基本单位，每个线程都有自己的程序计数器、栈、局部变量等，它们...
java多线程学习计划
最新发布
12-21
以下是一个Java多线程学习计划的简要介绍： 1. 学习多线程的基本概念：了解程序、进程和线程的概念，以及多线程的优点和何时需要使用多线程。 2. 学习线程的创建和使用：掌握使用Thread类创建和启动线程的方法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值