Java 线程

在java.lang.Thread下已经有封装好的线程类

线程的生命周期

1.新建状态(NEW)

实例化线程的时候

2.运行状态(RUNNABLE)

运行状态中又分就绪状态和可运行状态
(1)就绪状态：调用线程的start()方法之后，等待JVM调度的过程，要注意的是一个线程只能调用一次start()方法，再次调用则会报错，然后如果需要再次执行就需要重新实例化一个线程
(2)可运行状态：线程对象获得JVM调度

3.阻塞状态(BLOCKED)

线程放弃CPU分配，暂时停止运行，此时JVM不会给线程分配CPU，需等线程进入就绪状态后才能再得到分配调度

4.等待状态(WAITING)

该状态下只能等待其他线程唤醒，使用wait()方法进入该状态

5.计时等待状态(TIMED_WAITING)

进入一定时间的等待状态，使用wait(time)/Thread.sleep(time)进入该状态

6.终止状态(TERMINATED)

当执行完run()方法或遇到异常退出后的状态

创建线程

方法一

1.定义一个类继承于Thread
2.重写public void run(){}方法
3.生成该对象
举例：

public class Test {
    public static void main(String[] args){
        Count c = new Count();
        c.start();  //直接启动
        for(int i=0; i<100; i++)
            System.out.println("Main:"+i);
    }
}

class Count extends Thread {    //继承Thread
    public void run(){  //重写run()
        for(int i=0; i<100; i++)
            System.out.println("Count:"+i);
    }
}
方法二

1.定义线程类继承Runnable接口，里面只有一个public void run(){}方法
2.实例化一个线程类，然后将Runnable接口传入
其中使用Runnable接口可以为多个线程提供共享的数据，且在Runnable接口类的run方法中可以使用Thread的静态方法，如currentThread()为获取当前线程的引用
举例：

public class Test {
    public static void main(String[] args){
        Count c = new Count();  //实例化
        Thread t = new Thread(c);   //实例化线程
        t.start();  //启动线程
        for(int i=0; i<100; i++)
            System.out.println("Main:"+i);
    }
}

class Count implements Runnable {   //继承Runnable
    public void run(){  //重写run()
        for(int i=0; i<100; i++)
            System.out.println("Count:"+i);
    }
}
两种方式对比

在第一种方式中，每次都得实例化一个对象，所以每个的数据都是单独的，而且类是单继承的，此时就不能再继承其他类了，但是继承线程类后就可以直接调用其下的一些方法，操作上也就更加方便；在第二种方式中则可以实例化一个对象，然后将这一个对象放入多个线程当中，即可实现数据共享，但是因为不是继承线程类，所以没有线程类的方法控制，如果需要使用那些方法，则需要通过Thread.currentThread()来获得当前线程，然后调用那些方法。第二种线程数据共享及调用线程方法举例：

public class Test {
    public static void main(String[] args) {
        System.out.println(1);
        ThreadTest tt = new ThreadTest();
        new Thread(tt).start(); //不取名则默认名Thread-0
        new Thread(tt, "bbb").start();
        new Thread(tt, "ccc").start();
    }
}

class ThreadTest implements Runnable{
    public int i = 10;
    public void run() {
        for(;i>0;i--)
            System.out.println(Thread.currentThread().getName() + ":" + i);  //获取当前线程
    }   
}

因为三个线程都是公用i的值，所以总共也只输出10次

内部类创建线程

当线程只是一次性使用的情况下，可以使用该方式创建线程，举例：

//方法1的内部类线程创建
new Thread() {
    public void run() {
        for (int i = 0; i < 500; i++)
            System.out.println("Runnable:" + i);
    }
}.start();

//方法2的内部类线程创建
new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 500; i++)
            System.out.println("Thread:" + i);
    }
}).start();

启动线程

使用start()方法启动一个新线程，而run()则是调用线程里的方法体，并不会启动一个新线程

线程控制方法

即Thread类下的常用方法如下

getName()

获取当前线程名称

isAlive()

线程是否启动或者未终止

getPriority()

获取线程优先级数值

setPriority()

设置线程优先级数值，优先级越高，那么分配到的时间片越多，其中优先级范围为1~10，默认为5，一些优先级常量：

Thread.MIN_PRIORITY = 1
Thread.MAX_PRIORITY = 10
Thread.NORM_PRIORITY = 5
sleep()

线程睡眠多少毫秒，一旦睡眠期间被打断则会抛出InterruptedException异常

interrupt()

打断线程

join()

将当前线程与该线程合并，即把join的线程先执行完再执行当前线程，会抛出InterruptException，例如在main函数：

Count c = new Count();
c.start();
try{
    c.join();
}catch(InterruptedException e){
    ;
}

于是会先把c线程的内容执行完然后继续执行主线程

setDaemon()

设置守护线程，此时只要主线程没结束，该线程就不会结束，必须在线程启动前设置，举例：

Thread thread = new Thread(new Runnable() {
    public void run() {
        for (int i = 0; i < 100; i++)
            System.out.println(Thread.currentThread().getName() + ":" + i);
    }
});
thread.setDaemon(true); // 设置守护线程
thread.start();
isDaemon()

判断是否为守护线程

yield()

让出CPU，让线程进入就绪队列等待调度，举例：

public void run(){
    for(int i=0; i<100; i++){
        System.out.println("Count:"+i);
        if(i%10 == 0)
            yield();    //当i为10的倍数时让给别的线程调度
    }
}
wait()

让当前线程进入对象的等待池，释放同步锁，如果无参则是永久等待，有参则可以设置等待时间。要注意的是这个和下面的notify()方法都是java.lang.Object下的方法，而不是Thread下的方法，并且需要在同步锁的情况下才有用，即synchronized (this){}包着才行

notify()/notifyAll()

唤醒等待池的任意一个/所有等待线程，结合该方法和上面的方法，基本的生产者消费者模型如下：

public class Test {
    public static void main(String[] args) throws Exception {
        Resource r = new Resource();
        new Thread(new Producer(r), "Producer").start(); // 生产者
        new Thread(new Consumer(r), "Consumer1").start(); // 消费者
        new Thread(new Consumer(r), "COnsumer2").start(); // 消费者
    }
}

class Resource {
    int num = 0;

    synchronized public void push() {
        try {
            if (num >= 5) { // 当数量大于5个时进入等待
                this.wait();
            }
            System.out.println(Thread.currentThread().getName() + ":+1,"
                    + ++num);
            Thread.sleep(1000);
            this.notifyAll(); // 唤醒所有消费者线程

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void pop() {
        while (num <= 0) { // 当数量大于0的时候取出，否则线程等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + ":-1," + --num);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.notifyAll(); // 唤醒生产者线程
    }
}

class Producer implements Runnable {
    Resource r = null;

    public Producer(Resource r) {this.r = r;}

    public void run() {
        while (true)
            this.r.push();
    }
}

class Consumer implements Runnable {
    Resource r = null;

    public Consumer(Resource r) {this.r = r;}

    public void run() {
        while (true)
            this.r.pop();
    }
}
stop()

杀死线程，基本已经被废弃的方法

同步问题

当程序执行时可能会因为线程的同步机制而导致一些问题，比如下面的代码：

public class Test {
    public static void main(String[] args) {
        Count c1 = new Count();
        Count c2 = new Count();
        c1.start();
        c2.start();
    }
}

class Count extends Thread{
    static int num = 0; //计数变量
    public void run(){
        num++;  //执行自增后休眠一秒
        try{
            Thread.sleep(1000);
        }catch (InterruptedException e) {
            ;
        }
        System.out.println(getName() + ":" + num);
    }
}
结果为：
Thread-1:2
Thread-0:2

可以发现两个并非一个是1一个是2，而都是2，这是因为第一个自增后休眠，于是第二个也对num进行了自增，结果导致输出时数据都为2，因此为了防止这种问题，在执行该部分（自增+休眠）时我们不应该让另一个线程掺合进来，所以需要对这块加一个同步锁（保证同一时间内只允许一个线程执行的代码块）。

同步修饰符

使用synchronize(当前对象类型){}来将某一部分代码块包起来即可实现互斥，举例对上面的类进行修改：

class Count extends Thread{
    static int num = 0;
    public void run(){
        System.out.println(getName());  //这里不会互斥
        synchronized (this.getClass()) {    //这块会互斥，用Count.class也行
        num++;
        try{Thread.sleep(1000);}
        catch (InterruptedException e) {}
        System.out.println(getName() + ":" + num);
        }
    }
}
结果为：
Thread-0
Thread-1
Thread-0:1
Thread-1:2

要注意这里的两个线程里是不同的实例化对象，所以用synchronized (this.getClass())对其进行互斥，即对当前对象设置同步锁，如果是对同一个对象进行互斥则直接synchronize(this)就行了，举例：

public class Test {
    public static void main(String[] args) {
        Count c1 = new Count();
        Thread t1 = new Thread(c1);
        Thread t2 = new Thread(c1); //同一个c1
        t1.start();
        t2.start();
    }
}

class Count implements Runnable{
    static int num = 0;
    public void run(){
        System.out.println(Thread.currentThread().getName());
        synchronized (this) {  //用Count.class也行
            num++;
            try{Thread.sleep(1000);}
            catch (InterruptedException e) {}
            System.out.println(Thread.currentThread().getName() + ":" + num);   
    }
    }
}
结果为：
Thread-0
Thread-1
Thread-0:1
Thread-1:2

注：
synchronized虽然安全，但是性能损耗更低，所以尽量减少其的作用域，原来的ArrayList/Vector、HashMap/HashTable、StringBuilder/StringBuffer等一个效率高，一个更安全，其主要区别就是是否有使用synchronized修饰符

同步方法

用synchronized修饰的方法，对于非静态方法，同步锁就是this；对于静态方法，则使用当前方法所在类的字节码对象，即类.class。
线程执行的就是run()方法，如果给该方法加上同步修饰符，那么整个run()方法期间都无法执行其他线程，也就相当于单线程了，因此不要给run()方法添加同步修饰符。一般都是给要同步的部分单独写一个方法，然后加上同步修饰符

同步锁

在java.util.concurrent.locks下提供了同步锁的接口Lock，是比同步修饰符有更多功能

lock()/unlock()

获取锁/释放锁，举例：

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

public class Test {
    public static void main(String[] args) throws Exception {
        ThreadTest tt = new ThreadTest();
        new Thread(tt, "aaa").start();
        new Thread(tt, "bbb").start();
        new Thread(tt, "ccc").start();
    }
}

class ThreadTest implements Runnable {
    public int num = 100;
    public final Lock lock = new ReentrantLock();   //先定义同步锁

    public void run() {
        for (int i = 0; i < 100; i++) {
            // synchronized (this) {
            lock.lock();    //换成lock()同步锁
            try {
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    Thread.sleep(100);
                    num--;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();  //最后记得关闭锁
            }
            // }
        }
    }
}
newCondition()

返回一个Condition接口对象，用来监视线程，里面有await()/signal()/signalAll()方法用来替代wait()/notify()/notifyAll()方法，举例：

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

public class test {
    static int num = 100;
    static int flag = 1;
    static Lock lock = new ReentrantLock();  //一个锁
    static Condition c1 = lock.newCondition();  //三个监视器
    static Condition c2 = lock.newCondition();
    static Condition c3 = lock.newCondition();

    public static void main(String[] args) throws Exception {
        new Thread() {
            public void run() {
                while (true)
                    print1();
            };
        }.start();
        new Thread() {
            public void run() {
                while (true)
                    print2();
            };
        }.start();
        new Thread() {
            public void run() {
                while (true)
                    print3();
            };
        }.start();

    }

    public static void print1() {
        lock.lock();
        while(flag != 1) {
            try {
                c1.await();  //等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        if(num == 0){
            System.exit(0);
        }
        System.out.println("1:" + --num);
        flag = 2;
        c2.signalAll();  //唤醒
        lock.unlock();
    }

    public static void print2() {
        lock.lock();
        while(flag != 2) {
            try {
                c2.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        if(num == 0){
            System.exit(0);
        }
        System.out.println("2:" + --num);
        flag = 3;
        c3.signalAll();
        lock.unlock();
    }

    public static void print3() {
        lock.lock();
        while(flag != 3) {
            try {
                c3.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        if(num == 0){
            System.exit(0);
        }
        System.out.println("3:" + --num);
        flag = 1;
        c1.signalAll();
        lock.unlock();
    }
}
await()

相当于wait()

signal()/signalAll()

相当于notify()/notifyAll()

线程组

使用ThreadGroup类来创建线程组对象，默认情况下所有线程都属于主线程组

getThreadGroup()

线程下的方法，用于获取线程对象所属组，其下还有getName()方法用于获取线程名，举例：

Thread t = new Thread(new ThreadTest());
System.out.println(t.getThreadGroup().getName());  //main
Thread(ThreadGroup, thread)

线程的实例化方法当中支持传入线程组和线程，此时该线程就会被加入到指定的线程组，举例：

ThreadGroup tg = new ThreadGroup("no-main");
Thread t = new Thread(tg, new ThreadTest());
System.out.println(t.getThreadGroup().getName());   //no-main

线程池

通过ExecutorService来存储线程池对象，通过Executors下newFixedThreadPool(int)方法创建一定数量的线程池

submit()

将线程放入线程池并执行，举例：

ExecutorService pool = Executors.newFixedThreadPool(2);  //线程池里有2个线程
Thread t1 = new Thread(new ThreadTest());
pool.submit(t1);
pool.submit(t1);

结果：
pool-1-thread-1
pool-1-thread-2
shutdown()

上面的代码执行结束后，线程池并没有关闭，所以需要该方法来关闭线程池

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 200,302评论 5赞 470
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 84,232评论 2赞 377
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 147,337评论 0赞 332
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 53,977评论 1赞 272
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 62,920评论 5赞 360
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,194评论 1赞 277
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,638评论 3赞 390
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,319评论 0赞 254
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,455评论 1赞 294
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,379评论 2赞 317
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,426评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,106评论 3赞 315
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,696评论 3赞 303
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,786评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,996评论 1赞 255
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,467评论 2赞 346
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,043评论 2赞 341

推荐阅读更多精彩内容

  • Java线程面试题
    下面是我自己收集整理的Java线程相关的面试题，可以用它来好好准备面试。 参考文档：-《Java核心技术 卷一》-...
    阿呆变Geek阅读 14,734评论 14赞 507
  • JAVA多线程
    进程和线程 进程 所有运行中的任务通常对应一个进程,当一个程序进入内存运行时,即变成一个进程.进程是处于运行过程中...
    胜浩_ae28阅读 5,084评论 0赞 23
  • 自我提升（基础技术篇）——java线程简介
    前言：虽然自己平时都在用多线程，也能完成基本的工作需求，但总觉得，还是对线程没有一个系统的概念，所以，查阅了一些资...
    justCode_阅读 698评论 0赞 9
  • JAVA 线程
    【JAVA 线程】 线程 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者...
    Rtia阅读 2,748评论 2赞 20
  • 2018欧游记（十）
    7月19日一早巴黎当地7点我就离开酒店前往机场了。到了机场的第一件事情就是办退税！退税的手续挺复杂的，首先...
    心晴书院阅读 361评论 0赞 0