码迷,mamicode.com
首页 > 编程语言 > 详细

Java多线程基础

时间:2016-07-22 19:27:23      阅读:233      评论:0      收藏:0      [点我收藏+]

标签:

点此访问GitPage,颜色要好看点

什么是线程

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。

上面是网络上对“线程”的解释,可以看到线程具有以下特点:
- 被包含在进程中, 那么问题来了:什么是进程?大学老师曾问过同样的问题,当时我在座位上答道:运行中的程序。百度百科 进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。
- 线程是单一顺序的控制流,朴素来说线程中执行的代码都是有确定的先后顺序的,每一步执行的环境都是确定的,没有不确定的因素。
- 线程可以并发执行,在一个java进程中的不同任务可以不必彼此等待,常见的场景有阻塞式IO、网络通信、界面交互等。

线程的基本语法

在JAVA中创建一个线程并执行任务有两种方式,继承Thread类或实现Runnable接口并重写run()方法。

继承Thread

class OneThread extends Thread {
    int sleep;
    OneThread(int sleep) {
        this.sleep = sleep;
    }
    @Override
    public void run() {
        while (true) {
            System.out.println("大家好,我是一个线程,我的名字叫:" + getName());

            try {
                TimeUnit.MILLISECONDS.sleep(sleep);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

run方法中编写线程的任务,请随意!
启动线程:

OneThread oneThread1 = new OneThread(411);
oneThread1.run();

很抱歉,上面是错误的启动方式,正确启动线程一定要调用start()方法:

OneThread oneThread1 = new OneThread(411);
OneThread oneThread2 = new OneThread(557);
oneThread1.start();
oneThread2.start();

感兴趣的娃子可以自己去执行看看;

实现Runnable接口

class OneRunnable implements Runnable {
   int sleep;
   OneRunnable(int sleep) {
       this.sleep = sleep;
   }

   @Override
   public void run() {
       while (true) {
           System.out.println("大家好,我是一个线程,我的名字叫:" + Thread.currentThread().getName());

           try {
               TimeUnit.MILLISECONDS.sleep(sleep);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
}

仔细看看区别,区别不大哈哈。
如何启动呢?

new Thread(new OneRunnable(411)).start();
new Thread(new OneRunnable(557)).start();

为什么两种都可以?

我们先看Thread类的构造方法之一:

public Thread(Runnable target) {
    // 线程的默认名字就是这么来的
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
...
  this.target = target;
...
}

构造Thread对象时出入的Runnable被保存到target对象了,然后呢? 回顾上面创建线程的方法发现,奇怪的地方是run()

@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

真相大白了,原来Thread默认的run方法就是调用target.run()。这就是为什么继承Thread和实现Runnable都可以创建线程。
细心的娃子们会注意到,Thread.run()上面有@Override, 为啥呢?

public class Thread implements Runnable {...}

Thread也是Runnable的一个实现类。

线程的状态

技术分享

新建

新建了一个线程对象。 new Thread()

可运行

也叫就绪状态。线程对象创建后被调用了start()方法后进入可运行状态。此时表示线程随时可以执行,等待线程调度选中获得CPU使用权

运行

在可运行状态的线程获得了CPU时间片,执行程序代码

阻塞

阻塞状态是指线程因为某种原因放弃了CPU的使用权,暂停运行。知道线程进入可运行状态。阻塞分三种情况:
- 等待阻塞:运行 的线程执行了o.wait()方法, JVM会把该线程放到等待队列中。
- 同步阻塞:运行 的线程在获取对象的同步锁时,若该对象的锁被其他线程占用,则JVM会把改下昵称放入锁池中。
- 其他阻塞:运行 的线程执行Thread.sleep(long ms)t.join()方法,或者发出了I/O请求时, JVM会阻塞该线程。

死亡

线程run()结束或者遭遇一场,则结束该线程的生命周期。死亡的线程不能复生。

共享

在多线程环境,如果多线程一起访问公共资源没有任何限制,事情就不可控了。具体例子就不列举了,大家都懂。
因此在多线程环境,我们要用一种方式来控制资源在关键时刻只能被单一线程依次占有,不能一起上。

volatile

如果一个域声明为volatile,那么只要对这个域产生了写操作,所有的读操作就都可以看到这个修改。
在64位JVM中, long和double的读取和写入不是原子性的, 请加上volatile

Lock

手动的加锁与释放,这很灵活

public int next() {
   lock.lock();
   try {
       ++ currentEvenValue;
       Thread.yield();
       ++ currentEvenValue;
       return currentEvenValue;
   } finally {
       lock.unlock();
   }
}

一定要在finally里释放哦,return语句要在释放锁之前,不然不是完全的原子性。

synchronized

最常用的加锁方式。可使同步块内的代码原子性执行。

// 同步方法
public synchronized void test() {...}
// 同步块
synchronized(obj) {...}

锁的是什么?

能被锁的只能是对象, 那么像上述locksynchronized锁定的是什么呢?是当前对象this。其实整个过程是,线程1执行到同步方法时,去获得对象的锁,如果能获得则继续执行,并在执行结束时释放锁;如果锁已被别的线程占有则等待,等待别的线程释放锁。
所以下面的代码执行情况是?

public class SyncTask {
    public synchronized void f1(){
        System.out.println("f1 start");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("f1 end");
    }
    public synchronized void f2(){
        System.out.println("f2 start");
    }

    public static void main(String[] args) {
        SyncTask task = new SyncTask();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> task.f1());
        executorService.execute(() -> task.f2());
        executorService.shutdown();
    }
}

output:
f1 start
f1 end
f2 start

此处f1()f2()的锁都是对象本身, 所以线程1先执行f1()时获得了task的锁, 线程2执行f2()时去请求此锁只能等待,就出现了好像顺序执行的情况。
稍作处理,我们可以看到不同的情况:

public class SyncTask {
    Object a = new Object();
    public void f3(){
        synchronized (a) {
            System.out.println("f1 start");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f1 end");
        }
    }
    public synchronized void f2(){
        System.out.println("f2 start");
    }

    public static void main(String[] args) {
        SyncTask task = new SyncTask();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> task.f3());
        executorService.execute(() -> task.f2());
        executorService.shutdown();
    }
}

output:
f1 start
f2 start
f1 end

可以看到线程同时执行了。因为线程1此时锁的对象是a, 线程2锁的对象上task,两者没有冲突无需等待。
那么下面的情况会怎样?娃子们自己试试吧

public class SyncTask {
    Object b;

    public void f3(){
        synchronized (b) {
            System.out.println("f1 start");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("f1 end");
        }
    }
    ...
}

线程的一些小点

守护线程

JAVA中线程有两类用户线程守护线程
所谓的守护线程,是指用户程序在运行的时候后台提供的一种通用服务的线程,比如用于垃圾回收的垃圾回收线程。这类线程并不是用户线程不可或缺的部分,只是用于提供服务的”服务线程”。

// 设置守护线程
thread.setDaemon(true);

需要注意的地方:
- thread.setDaemon(true)必须在thread.start()之前设置,否则会跑出一个异常。你不能把正在运行的常规线程设置为守护线程。
- 在守护线程中产生的线程也是守护线程。
- 我们自己产生的守护线程应该避免访问一些类似于文件、数据库等固有资源,因为由于JVM没有用户线程之后,守护线程会马上终止。
对于第二点我们可以通过Thread类的源码来证明:

class Thread {
  init() {
    ...
    this.daemon = parent.isDaemon();
    ...
  }
}

线程优先级

线程优先级取值是1-10, 越大优先级越高。
线程的优先级无法保障线程的执行次序。只不过,优先级高的线程获取CPU资源的概率较大,优先级低的并非没机会执行。

thread.setPriority(10);

Java多线程基础

标签:

原文地址:http://blog.csdn.net/syy_c_j/article/details/51992683

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!