Java 线程学习

Java 线程相关

  1. 如何创建线程(两种方式,区别,使用场景)
  2. 线程状态调度
  3. 多线程数据共享(会有什么问题,如何实现共享,多线程操作同一个变量会有什么问题,如果不希望有问题怎么做)
  4. 数据传递
  5. 线程池相关(如何创建线程池,要注意什么(初始化线程内部变量),几种常用的使用方式)

1. 线程创建

通常创建线程有两种方式,一个是继承 Thread, 一个是实现 Runnable; 下面则分别实现以做演示,然后说一下这两种的区别,应该如何选择

创建线程

创建线程和使用的一个小case如下, 注意的是线程启动是调用start方法, 而不是 run 方法; 其次实现Runnable 接口的类,启动依然是放在一个Thread 对象中

public class ThreadCreate {


    /**
     * 通过继承  Thread 方式来创建一个新的线程
     */
    public static class ThreadExtend extends Thread {

        @Test
        public void run() {
            System.out.println("new extend thread");
        }
    }


    /**
     * 通过实现 Runnable 方式来创建一个线程
     */
    public static class RunnableImplement implements Runnable {

        @Override
        public void run() {
            System.out.println("new runnable thread");
        }
    }

    @Test
    public void testCreate() {
        new ThreadExtend().start();

        new Thread(new RunnableImplement()).start();

        System.out.println("main!");
    }

}

两种方式对比

为什么会有两种方式呢?这两种的区别何在?

  1. 实现是可以有多个的,但是继承只能有一个父类
  2. 查看 Runnable 的使用方法,最终是放在一个 Thread里面去执行的,所以在多个相同的程序代码处理一个资源时,这个还是有优势的;但是查看 Thread实际上就是 Runnable的实现,同样可以将一个自定义的Thread对象,创建多个 Thread对象来调用

通过上面的描述可以知道一点,如果你希望数据多线程内共享,不妨考虑实现 Runnable 接口(当然继承Thread也是ok的);如果希望隔离,则不妨考虑继承Thread (实际上使用 Runnable接口的实现也是ok的,多创建几个实现类接口对象而已,每个对象放在一个新的Thread中执行)

按照个人的理解,网上说的实现Runnable 方便资源共享,更多的是倾向于代码的共享,通常是一个Runnable对象,放在多个 Thread实例中执行;而继承 Thead类,从出发点来看,继承的一般是作为一个独立线程来执行使用,如果你真要像下面这么做,也不会报错,也能正常运行,只是有点违反设计理念而已

MyThread extreds Thread {...};
MyThread mythread = new MyThread();
new Thread(mythread).start();

case 举例

举一个例子,车站卖票,假设现在有三个窗口,总共只有30张车票,卖完就不卖了,怎么实现?如果每个窗口有10张车票,各个窗口把自己的卖完了就不卖了,怎么实现?

第一个case,符合数据共享的一种场景,那么我们的实现可以如下:

public static class TotalSaleTick implements Runnable {
   private int total = 30;

   @Override
   public void run() {
       while (true) {
           if (total > 0) {
               System.out.println(Thread.currentThread().getName() + "售出一张,剩余:" + --total);
           } else {
               break;
           }
       }
   }
}


@Test
public void testTotalSale() {
   TotalSaleTick totalSaleTick = new TotalSaleTick();
   Thread thread1 = new Thread(totalSaleTick, "窗口1");
   Thread thread2 = new Thread(totalSaleTick, "窗口2");
   Thread thread3 = new Thread(totalSaleTick, "窗口3");

   thread1.start();
   thread2.start();
   thread3.start();
   System.out.println("master over!");
}

输出如下, 基本上每次跑的输出结果都不一样, 可以看出的一点是三个窗口售出的票数不同,一个问题,上面这种情况,可能造成超卖么?

窗口1售出一张,剩余:29
master over!
窗口2售出一张,剩余:28
窗口2售出一张,剩余:25
窗口2售出一张,剩余:24
窗口1售出一张,剩余:27
窗口3售出一张,剩余:26
窗口1售出一张,剩余:22
窗口1售出一张,剩余:20
窗口1售出一张,剩余:19
窗口1售出一张,剩余:18
窗口1售出一张,剩余:17
窗口1售出一张,剩余:16
窗口1售出一张,剩余:15
窗口1售出一张,剩余:14
窗口1售出一张,剩余:13
窗口1售出一张,剩余:12
窗口1售出一张,剩余:11
窗口1售出一张,剩余:10
窗口2售出一张,剩余:23
窗口2售出一张,剩余:8
窗口2售出一张,剩余:7
窗口2售出一张,剩余:6
窗口2售出一张,剩余:5
窗口2售出一张,剩余:4
窗口1售出一张,剩余:9
窗口3售出一张,剩余:21
窗口3售出一张,剩余:1
窗口3售出一张,剩余:0
窗口1售出一张,剩余:2
窗口2售出一张,剩余:3

第二个case,则显然更倾向于继承 Thread 来实现了

public static class SplitSaleTick extends Thread {
   private int total = 10;

   public SplitSaleTick(String name) {
       super(name);
   }

   @Override
   public void run() {
       while (true) {
           if (total > 0) {
               System.out.println(Thread.currentThread().getName() + "售出一张,剩余:" + --total);
           } else {
               break;
           }
       }
   }
}


@Test
public void testSplitSaleTick() {
   SplitSaleTick splitSaleTick1 = new SplitSaleTick("窗口1");
   SplitSaleTick splitSaleTick2 = new SplitSaleTick("窗口2");
   SplitSaleTick splitSaleTick3 = new SplitSaleTick("窗口3");

   splitSaleTick1.start();
   splitSaleTick2.start();
   splitSaleTick3.start();
   System.out.println("master over");
}


/**
* 继承 Thread 也可以实现共享, 只不过比较恶心而已
*/
@Test
public void testSplitSaleTick2() {
   SplitSaleTick splitSaleTick1 = new SplitSaleTick("saleTick");

   Thread thread1 = new Thread(splitSaleTick1, "窗口1");
   Thread thread2 = new Thread(splitSaleTick1, "窗口2");
   Thread thread3 = new Thread(splitSaleTick1, "窗口3");

   thread1.start();
   thread2.start();
   thread3.start();
}

输出接过如下, 三个窗口可以并发卖,且每个窗口卖10张,卖完即止

窗口1售出一张,剩余:9
窗口2售出一张,剩余:9
窗口2售出一张,剩余:8
窗口1售出一张,剩余:8
窗口1售出一张,剩余:7
窗口1售出一张,剩余:6
窗口1售出一张,剩余:5
窗口1售出一张,剩余:4
窗口2售出一张,剩余:7
窗口1售出一张,剩余:3
窗口1售出一张,剩余:2
窗口1售出一张,剩余:1
窗口1售出一张,剩余:0
窗口3售出一张,剩余:9
窗口3售出一张,剩余:8
窗口3售出一张,剩余:7
窗口3售出一张,剩余:6
窗口3售出一张,剩余:5
窗口3售出一张,剩余:4
窗口3售出一张,剩余:3
窗口3售出一张,剩余:2
窗口3售出一张,剩余:1
窗口3售出一张,剩余:0
master over
窗口2售出一张,剩余:6
窗口2售出一张,剩余:5
窗口2售出一张,剩余:4
窗口2售出一张,剩余:3
窗口2售出一张,剩余:2
窗口2售出一张,剩余:1
窗口2售出一张,剩余:0


---- test2 输出 ----
窗口1售出一张,剩余:9
窗口1售出一张,剩余:6
窗口1售出一张,剩余:5
窗口1售出一张,剩余:4
窗口1售出一张,剩余:3
窗口1售出一张,剩余:2
窗口3售出一张,剩余:7
窗口2售出一张,剩余:8
窗口3售出一张,剩余:0
窗口1售出一张,剩余:1

2. 线程状态(线程生命周期)

线程创建之后,即调用了start方法之后,线程是否开始运行了?这个运行过程是否会暂停呢?如果需要暂停应该怎么办;如果一个线程依赖另一个线程的计算结果,又该如何处理?

  • 创建:新建一个线程对象,如Thread thd=new Thread()
  • 就绪:创建了线程对象后,调用了线程的start()方法(此时线程知识进入了线程队列,等待获取CPU服务 ,具备了运行的条件,但并不一定已经开始运行了)
  • 运行:处于就绪状态的线程,一旦获取了CPU资源,便进入到运行状态,开始执行run()方法里面的逻辑
  • 终止:线程的run()方法执行完毕,或者线程调用了stop()方法,线程便进入终止状态
  • 阻塞:一个正在执行的线程在某些情况系,由于某种原因而暂时让出了CPU资源,暂停了自己的执行,便进入了阻塞状态,如调用了sleep()方法
  • 线程让步: join 等待其他线程终止。在当前线程中调用另一个线程的join()方法,则当前线程转入阻塞状态,直到另一个进程运行结束,当前线程再由阻塞转为就绪状态

3. 方法说明

一个Thread实例有一些常用的方法如: start, sleep, run, yield, join, wait 等, 这些方法是干嘛用的,什么场景下使用,使用时需要注意些什么? 方法的执行,将对应线程状态进行说明

run 方法

run 方法中为具体的线程执行的代码逻辑,一般而言,都不应该被直接进行调用

无论我们采用哪种方法创建线程,基本上都是要重写run 方法,这个方法会在线程执行时调用

start 方法

执行该方法之后,线程进入就绪状态,对使用者而言,希望线程执行就是调用的这个方法(注意调用之后不会立即执行)

这个方法的主要目的就是告诉系统,我们的线程准备好了,cpu有空了赶紧来执行我们的线程

sleep 方法

睡眠一段时间,这个过程中不会释放线程持有的锁, 传入int类型的参数,表示睡眠多少ms 让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源,以留一定时间给其他线程执行的机会

我们最常见的一种使用方式是在主线程中直接调用 Thread.sleep(100) , 表示先等个100ms, 然后再继续执行

wait 方法

wait()方法是Object类里的方法;当一个线程执行到wait()方法时,它就进入到一个和该对象相关的等待池中,同时失去(释放)了对象的机锁(暂时失去机锁,wait(long timeout)超时时间到后还需要返还对象锁);其他线程可以访问

wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程

通常我们执行wait方法是因为当前线程的执行,可能依赖到其他线程,如登录线程中,若发现用户没有注册,则等待,等用户注册成功后继续走登录流程(我们不考虑这个逻辑是否符合实际),

这里就可以在登录线程中调用 wait方法, 在注册线程中,在执行完毕之后,调用notify方法通知登录线程,注册完毕,然后继续进行登录后续action

yield 方法

暂停当前正在执行的线程对象,并执行其他线程 yield()应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。因此,使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是,实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中

这个方法的执行,有点像一个拿到面包的人对另外几个人说,我把面包放在桌上,我们从新开始抢,那么下一个拿到面包的还是这些人中的某个(大家机会均等)

想象不出啥时候会这么干

join 方法

启动线程后直接调用,即join()的作用是:“等待该线程终止”,这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码,只有等到子线程结束了才能执行

从上面的描述也可以很容易看出什么场景需要调用这个方法,主线程和子线程谁先结束不好说,如果主线程提前结束了,导致整个应用都关了,这个时候子线程没执行完,就呵呵了;其次就是子线程执行一系列计算,主线程会用到计算结果,那么就可以执行这个方法,保证子线程执行完毕后再使用计算结果

4. 数据共享

多线程间数据共享,当多线程公用一个Runnable对象时,这个对象中的成员变量即可以达到数据共享的目的;多线程采用不同的Runnable对象时,数据怎么共享

公用 Runnable对象时

上面的售票例子中,其实就有这个场景,上面提出了一个问题,是否会出现超卖的情况?

  1. 因为我们知道 ++ 不是原子操作, 实际可以拆分为三步:
    • 内存到寄存器
    • 寄存器自增
    • 写回内存

    假设num为10时, 线程A和线程B都调用 ++num操作;对于内存到寄存器这一步,两个线程都到了这一步,A自增将11写回内存,B也进行自增将11写会内存,这个时候就少+1了

  2. 读一个long,double类型的共享变量时,也不是原子操作,在32位操作系统上对64位的数据的读写要分两步完成,每一步取32位数据,如果有两个线程同时写一个变量内存,一个进程写低32位,而另一个写高32位,这样将导致获取的64位数据是失效的数据

在多线程中,共享数据的获取or更新,请确保是原子操作;可以考虑同步锁(synchronized)修改共享变量,共享变量前添加volatile, 使用原子数据类型 AtomicInteger

修改上面的售票代码如下

public static class TotalSaleTick implements Runnable {
        private int total = 30;

        @Override
        public void run() {
            while (true) {
                synchronized (this) {
                    if (total > 0) {
                        System.out.println(Thread.currentThread().getName() + "售出一张,剩余:" + --total);
                    } else {
                        break;
                    }
                }
            }
        }
    }

一个小疑惑,在实际的测试中,即便是上面不加上同步块,好像也没有出问题,对于上面的操作可能运行很多遍都是正确的, 好像和我们预期的不相符,有没有可能是因为总数太少,导致冲突的机率变小了?

private AtomicInteger count = new AtomicInteger(0);
private int sum = 3000;

public class MyThread extends Thread {
   public void run() {
       while (true) {
           if (sum > 0) {
               count.addAndGet(1);
               --sum;
           }else {
               break;
           }
       }
       System.out.println(Thread.currentThread().getName() + " over " + sum);
   }
}


@Test
public void testAdd() throws InterruptedException {
   MyThread myThread1 = new MyThread();
   MyThread myThread2 = new MyThread();

   myThread1.start();
   myThread2.start();

   myThread1.join();
   myThread2.join();

   System.out.println("num: " + sum + " count: " + count.get());
}

对上面的场景,多运行几次,发现输出结果果然是超卖了

Thread-1 over -1
Thread-0 over -1
num: -1 count: 3008

非公用的 Runnable 对象时

共享全局变量 + 共享局部变量两种情况,有点区别

上面的case就是一个共享全局变量的demo,上面出现了并发冲突,可以如下解决, 针对类进行加锁

public class ThreadShareTest {
    private AtomicInteger count = new AtomicInteger(0);
    private int sum = 3000;

    public class MyThread extends Thread {
        public void run() {
            while (true) {
                if (sum > 0) {
                    synchronized (ThreadShareTest.class) {
                        if (sum > 0) {
                            count.addAndGet(1);
                            --sum;
                        }
                    }
                }else {
                    break;
                }
            }
            System.out.println(Thread.currentThread().getName() + " over " + sum);
        }
    }


    @Test
    public void testAdd() throws InterruptedException {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();

        myThread1.start();
        myThread2.start();

        myThread1.join();
        myThread2.join();

        System.out.println("num: " + sum + " count: " + count.get());
    }
}

共享局部变量,需要注意的是局部变量要求是final, 所以下面的int采用了数组的形式(基本类型无法修改,引用类型可以改其内部的值, 不能改引用)

@Test
public void testAdd2() throws InterruptedException {
   final int[] num = {3000};
   final AtomicInteger c = new AtomicInteger(0);


   Runnable runnable = new Runnable() {
       @Override
       public void run() {
           while (true) {
               if (num[0] > 0) {
                   c.addAndGet(1);
                   num[0]--;
               } else {
                   break;
               }
           }

           System.out.println(Thread.currentThread().getName() + " over " + num[0]);
       }
   };

   Thread thread1 = new Thread(runnable);
   Thread thread2 = new Thread(runnable);

   thread1.start();
   thread2.start();

   thread1.join();
   thread2.join();

   System.out.println("num: " + num[0] + " count: " + c.get());
}

多运行几次,输出如下,说明也存在并发的问题了, 修正方式同样是加锁

Thread-0 over -1
Thread-1 over -1
num: -1 count: 3001

修改后的run方法内部如下

while (true) {
     if (num[0] > 0) {
         synchronized (this) {
             if (num[0] > 0) {
                 c.addAndGet(1);
                 num[0]--;
             } else {
                 break;
             }
         }
     } else {
         break;
     }
 }

线程数据隔离

上面是数据在多线程中共享,很容易出现的就是并发问题;还有一个场景就是我希望不存在数据共享,线程操作的内部变量不影响其他的线程; 最简单的想法就是一个继承了Thread的类,其内部类正常来讲就是隔离的,只要你不把它当成 Runnable 接口的使用方式就行

使用 ThreadLocal 来保证变量在线程之间的隔离, 下面是一个简单的演示,两个线程都是在修改threadLocal中的值, 但是两个线程的修改,对彼此而言是独立的

public static class LocalT implements Runnable {
   ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

   @Override
   public void run() {
       int start = (int) (Math.random() * 100);
       for (int i =0 ; i < 100; i = i+2) {
           threadLocal.set(start + i);
           System.out.println(Thread.currentThread().getName() + " : " + get());
       }
   }

   public int get() {
       return threadLocal.get();
   }
}


@Test
public void testLocal() throws InterruptedException {
   LocalT local = new LocalT();

   Thread thread1 = new Thread(local);
   Thread thread2 = new Thread(local);

   thread1.start();
   thread2.start();

   thread1.join();
   thread2.join();
}

5. 数据传递

数据如何传递给线程,有如何把线程计算的结果抛出来

传递数据

比较容易想到的就是在创建对象时,传入数据;或者调用线程对象的setXXX方法传入数据, 当做正常的对来操作处理即可

需要注意的是,在线程的执行期间,你修改了其中的局部变量,会出现什么情况呢?

public static class ThreadData implements Runnable {
   private int num = 0;


   public void run() {
       while (num < 100) {
           System.out.println(Thread.currentThread().getName() + " now: " + num++);
       }

       System.out.println(Thread.currentThread().getName() + " num: " + num);
   }

   public void setNum(int num) {
       System.out.println(this.num + " now set to " + num);
       this.num = num;
   }
}


@Test
public void testThreadSetData() throws InterruptedException {
   ThreadData threadData = new ThreadData();

   Thread thread1 = new Thread(threadData);
   Thread thread2 = new Thread(threadData);

   thread1.start();
   thread2.start();

   threadData.setNum(200);

   thread1.join();
   thread1.join();
}

输出如下, 将num设置为200之后,并没有如我们预期的结束线程,依然在往下走, 这里就相当于是有一个你修改了这个数据,是否会立马就生效呢?特别是对其他的线程而言

...
Thread-1 now: 24
Thread-1 now: 25
Thread-0 now: 14
26 now set to 200
Thread-0 now: 27
Thread-0 now: 28
Thread-1 now: 26
Thread-0 now: 29
Thread-1 now: 30
....

输出结果

线程执行了一个任务之后,输出的结果可以怎么处理

一个实例,一个线程实现累加的过程,我现在希望实现1 加到 100, 开四个线程,怎么做?

下面是一个实现,不知道有没有什么问题

public static class CalculateThread extends Thread {

   private int start;
   private int end;

   private int ans;

   public CalculateThread(int start, int end) {
       this.start = start;
       this.end = end;
   }

   public void run() {
       for (int i = start; i <= end; i++) {
           ans += i;
       }
   }

   public int getAns() {
       return ans;
   }
}


@Test
public void testCalculate() throws InterruptedException {
   CalculateThread c1 = new CalculateThread(1, 25);
   CalculateThread c2 = new CalculateThread(26, 50);
   CalculateThread c3 = new CalculateThread(51, 75);
   CalculateThread c4 = new CalculateThread(76, 100);

   c1.start();
   c2.start();
   c3.start();
   c4.start();


   c1.join();
   c2.join();
   c3.join();
   c4.join();

   System.out.println("ans1: " + c1.getAns() + " ans2: " + c2.getAns() + " ans3: " + c3.getAns() + " ans4: " + c4.getAns());
   int ans = c1.getAns() + c2.getAns() + c3.getAns() + c4.getAns();
   System.out.println("ans : " + ans);
}

6. 线程池

多线程技术主要解决处理器单元内多个线程执行的问题,它可以显著减少处理器单元的闲置时间,增加处理器单元的吞吐能力 线程的频繁创建和销毁可能浪费大量的时间,线程池就是为了解决这个问题而产生

参考

  • Java多线程操作局部变量与全局变量
  • Java多线程学习(吐血超详细总结)
  • 深入理解Java之线程池

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Python专栏

Python | 判定IP地址合法性的三种方法

IP合法性校验是开发中非常常用的,看起来很简单的判断,作用确很大,写起来比较容易出错,今天我们来总结一下,看一下3种常用的IP地址合法性校验的方...

2193
来自专栏Leetcode名企之路

jvm类加载机制

类从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括:加载、验证、准备、解析、初始化、使用和卸载七个阶段。

1273
来自专栏眯眯眼猫头鹰的小树杈

猫头鹰的深夜翻译:理解java的classloader

Java ClassLoader是java运行系统中一个至关重要但是经常被忽略的组件。它负责在运行时寻找并加载类文件。创建自定义的ClassLoader可以彻底...

1394
来自专栏用户2442861的专栏

《Java虚拟机原理图解》 1.1、class文件基本组织结构

http://blog.csdn.net/luanlouis/article/details/39892027

882
来自专栏JavaEdge

JVM内存模型1 程序计数器2. Java虚拟机栈(JVM Stack)3. 本地方法栈(Native Method Stack)4 Java堆(Java Heap)5 方法区6 直接内存(Direc

4319
来自专栏专注 Java 基础分享

虚拟机类加载机制

虚拟机把字节码文件从磁盘加载进内存的这个过程,我们可以粗糙的称之为「类加载」,因为「类加载」不仅仅是读取一段字节码文件那么简单,虚拟机还要进行必要的「验证」、「...

4657
来自专栏向治洪

java基础Haep(堆)和Stack(栈)区别

简单的可以理解为: heap:是由malloc之类函数分配的空间所在地。地址是由低向高增长的。  stack:是自动分配变量,以及函数调用的时候所使用的一些空...

2107
来自专栏Java技术分享圈

杨老师课堂之JavaSe 部分面试题

​ JVM 是 JavaVirtual Machine 的缩写,全称是 Java 虚拟机。Java 语言的一个非常重要的 特性就是跨平台性,而 Java 虚...

893
来自专栏nnngu

01 深入理解JVM的内存区域

先来看看JVM运行时候的内存区域,如下图: ?   大多数 JVM 将内存区域划分为 Heap(堆)、方法区、Stack(栈)、本地方法栈、程序计数器。其中 H...

2785
来自专栏JMCui

Redis学习一(基础入门).

一、前言     Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、key-Value 的数据库、并提供多...

3855

扫码关注云+社区

领取腾讯云代金券