Java多线程高并发学习笔记(一)——Thread&Runnable

 进程与线程

首先来看百度百科关于进程的介绍:

进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。它可以申请和拥有系统资源,是一个动态的概念,是一个活动的实体。它不只是程序的代码,还包括当前的活动,通过程序计数器的值和处理寄存器的内容来表示。 

直观一点:

windows的任务管理里面,我们看到的eclipse和360等等,都是进程。(想深入了解的可以看看计算机操作系统)

什么是线程?

线程是在一个进程独立运行的子任务。线程是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源。

打个比如说,我们都用的QQ软件,它是一个进程,我们可以和人一边聊天一边传输文件,这就是多线程。

为什么要使用多线程?

1.多线程可以充分的利用系统的cpu,达到更快的处理效果

2.提高系统的运行效率

想入更深入了解的可以重新学习计算机操作系统,这里就不多介绍了,接下来我们怎么用!(毕竟这才是关键)

Thread and Runnable

Java中实现线程有两个方式,一个是继承Thread,另一个是实现Runnable接口,首先来看继承Thread的第一个实例:

package com.chapter1;

public class FirstThread {

    public static void main(String[] args) {
        InnerThread thread = new InnerThread();
        // 线程启动
        thread.start();
    }

}

class InnerThread extends Thread {

    // Override run方法,写入自己想要实现的业务
    @Override
    public void run() {
        super.run();
        System.out.println("Hello World!");
    }
}

 继承run方法的时候,我们通常会重写run方法,来实现自己的业务,接下来看,如何使用Runnable实现线程:

package com.chapter1;

public class FirstRunnable {

    public static void main(String[] args) {
        MyRunnable myRunnable;
        myRunnable = new MyRunnable();
        new Thread(myRunnable).start();
    }

}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Hello World!");
    }
}

Runnable是一个接口,接口意味着更加灵活一些,也是推荐使用实现Runable接口来写线程的。

 现在我们看到的都是一个单线程的例子,接下来写一个多线程的:

package com.chapter1;
/**
 * 多个线程实例
 * @author tangj
 *
 */
public class ManyThread {

    public static void main(String args[]) {
        Runnable runnable = new MyRunnable2();
        new Thread(runnable, "a").start();
        new Thread(runnable, "b").start();
        new Thread(runnable, "c").start();
        new Thread(runnable, "d").start();
    }
}

class MyRunnable2 implements Runnable {

    int count = 0;
    @Override
    public void run() {
        autoIncrement();
        System.out.println(Thread.currentThread().getName()+"计算了"+"count:" + count);
    }
    // 执行自增操作
    private void autoIncrement(){
        count++;
    }
}

我们来看下运行结果:

再运行一次

可以看到,多线程的执行是无序的,而且这个结果有点奇怪,难道不是从1增加到4吗,怎么会出现重复的?

在JVM中,执行自增操作的分为三个步骤:

1.取得现有值count

2.执行count+1操作

3.将count+1赋值给count.

所以就会遇到这样的情况,一个线程在取得count值的时候,count操作正处于第二个步骤,上一个线程执行的还未进行赋值操作,这就涉及到线程安全问题。

下面给出上一个例子的解决方案                                                               

package com.chapter1;

/**
 * 多个线程实例
 * 
 * @author tangj
 *
 */
public class ManyThread {

    public static void main(String args[]) {
        Runnable runnable = new MyRunnable2();
        new Thread(runnable, "a").start();
        new Thread(runnable, "b").start();
        new Thread(runnable, "c").start();
        new Thread(runnable, "d").start();
    }
}

class MyRunnable2 implements Runnable {

    int count = 0;

    // 注意在这里增加了关键字 synchronized
    @Override
    synchronized public void run() {
        autoIncrement();
        System.out.println(Thread.currentThread().getName() + "计算了" + "count:" + count);
    }

    // 执行自增操作
    private void autoIncrement() {
        count++;
    }
}

来看输出结果(多执行几次):

我们可以看到:不管哪个线程先执行,最后的打印顺序肯定是递增的顺序。

 接下来我们看另外一中实现方式:使用重入锁(ReentrantLock)

package com.chapter1;

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

public class ManyThread2 {

    public static void main(String[] args) {
        Runnable runnable = new MyRunnable3();
        new Thread(runnable, "a").start();
        new Thread(runnable, "b").start();
        new Thread(runnable, "c").start();
        new Thread(runnable, "d").start();
    }
}

class MyRunnable3 implements Runnable{
    
    int count = 0;
    // 使用重入锁ReentrantLock
    Lock lock = new ReentrantLock();
    
    @Override
    public void run() {
        // 锁住
        lock.lock();
        count++;
        System.out.println(Thread.currentThread().getName() + "计算了" + "count:" + count);
        // 解锁
        lock.unlock();
    }
    
}

得到的结果也是整齐的递增顺序,说明它也是线程安全的。

总结

所以以后开发多线程的业务的时候,首先应该考虑的问题应该是这样的一个流程:

1.能否用单线程解决?(单线程本身就是线程安全的)

2.我开发的多线程业务是否线程安全?

线程安全是保证程序正常运行的关键,所以应该把线程安全作为开发多线程对于考虑的首要问题

最后说两句:

本文所以代码都更新到我的github中,大家可以去clone或者Fork,我会持续更新的。

点击这里进入我的Github

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

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏用户2442861的专栏

Java虚拟机工作原理详解

http://blog.csdn.net/bingduanlbd/article/details/8363734

9510
来自专栏与神兽党一起成长

使用commons-pool管理FTP连接

在封装一个FTP工具类文章,已经完成一版对FTP连接的管理,设计了模板方法,为工具类上传和下载文件方法的提供获取对象和释放对象支持。

14720
来自专栏我的技术专栏

Java Thread wait、notify与notifyAll

15620
来自专栏java学习

1.3java的运行原理

java的运行原理 这里我们简单分析一下我们的第一个应用程序,其中涉及到很多没有接触过的概念,大家可先阅读以下,以后会详细讲解。重点是理解java的运行原理。 ...

38540
来自专栏我是攻城师

深入理解Java类加载器机制

Java里面的类加载机制,可以说是Java虚拟机核心组件之一,掌握和理解JVM虚拟机的架构,将有助于我们站在底层原理的角度上来理解Java语言,这也是为什么我们...

35320
来自专栏屈定‘s Blog

Java学习记录--委派模型与类加载器

最近在读许令波的深入分析Java Web技术内幕一书,对于学习Java以来一直有的几个疑惑得到了解答,遂记录下来.

16070
来自专栏Java架构师历程

JVM加载class文件的原理

当Java编译器编译好.class文件之后,我们需要使用JVM来运行这个class文件。那么最开始的工作就是要把字节码从磁盘输入到内存中,这个过程我们叫做【加载...

53720
来自专栏desperate633

Java线程通信(Thread Signaling)利用共享对象实现通信忙等(busy waiting)wait(), notify() and notifyAll()信号丢失(Missed Sign

线程通信的目的就是让线程间具有互相发送信号通信的能力。 而且,线程通信可以实现,一个线程可以等待来自其他线程的信号。举个例子,一个线程B可能正在等待来自线程A...

9720
来自专栏陈树义

Java并发编程:线程控制

在上一篇文章中(Java并发编程:线程的基本状态)我们介绍了线程状态的 5 种基本状态以及线程的声明周期。这篇文章将深入讲解Java如何对线程进行状态控制,比如...

40990
来自专栏JackeyGao的博客

Django小技巧08: Blank or Null

Django Model API 中提供了blank和null两个参数, 非常容易混淆。当我第一次使用 Django 的时候, 总是不能恰当的使用这两个参数。

7830

扫码关注云+社区

领取腾讯云代金券