Java之多线程

一、线程的引入：
定义：同时对多项任务加以控制

我们上下代码：

1.未使用线程

package com.learn.chap08.sec01;
/**
 * 未使用线程--同步执行
 * @author Administrator
 *
 */
public class Demo1 {
    
    /**
     * 听音乐
     */
    public static void music(){
        for (int i = 0; i < 5; i++) {
            System.out.println("听音乐");
        }
    }
    
    /**
     * 吃饭
     */
    public static void eat(){
        for (int i = 0; i < 5; i++) {
            System.out.println("吃饭");
        }
    }
    
    public static void main(String[] args) {
        music();
        eat();
    }
}

2. 使用线程

package com.learn.chap08.sec01;
/**
 * 使用多线程--异步执行
 * @author Administrator
 *
 */
public class Eat extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100); // 100毫秒
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("吃饭");
        }
    }
    
}

package com.learn.chap08.sec01;
/**
 * 使用多线程--异步执行
 * @author Administrator
 *
 */
public class Music extends Thread {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("听音乐");
        }
    }
    
}

package com.learn.chap08.sec01;
/**
 * 使用多线程--异步执行
 * @author Administrator
 *
 */
public class Demo2 {
    public static void main(String[] args) {
        /**
         * 利用多线程--实现一边听音乐 一边吃饭
         */
        Music musicThread = new Music();
        Eat eatThread     = new Eat();
        musicThread.start();
        eatThread.start();
    }
}

二、使用多线程

1. 继承Thread类

代码如下：

package com.learn.chap08.sec02;

public class Thread1 extends Thread {
    private String threadName;
    private int baoZi = 1;

    public Thread1(String threadName) {
        super();
        this.threadName = threadName;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(baoZi<=10){
            System.out.println(this.threadName+" 吃第"+baoZi+"个包子");
            baoZi++;
        }
    }
    
    public static void main(String[] args) {
        System.out.println("张三、李四各自吃10个包子");
        Thread1 t1=new Thread1("张三线程");
        Thread1 t2=new Thread1("李四线程");
        t1.start();
        t2.start();
    }
    
}

2. 实现Runnable接口

代码如下：

package com.learn.chap08.sec02;

public class Thread2 implements Runnable{

    private String threadName;
    private int baoZi = 1;

    public Thread2(String threadName) {
        super();
        this.threadName = threadName;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(baoZi<=10){
            System.out.println(this.threadName+" 吃第"+baoZi+"个包子");
            baoZi++;
        }
    }
    
    public static void main(String[] args) {
        System.out.println("张三、李四各自吃10个包子");
        Thread1 t1=new Thread1("张三线程");
        Thread1 t2=new Thread1("李四线程");
        Thread t11=new Thread(t1);
        Thread t12=new Thread(t2);
        t11.start();
        t12.start();
    }
    
}

package com.learn.chap08.sec02;

public class Thread3 implements Runnable{

    private String threadName;
    private int baoZi = 1;

    public Thread3(String threadName) {
        super();
        this.threadName = threadName;
    }

    @Override
    public synchronized void run() {
        // TODO Auto-generated method stub
        while(baoZi<=10){
            System.out.println(this.threadName+" 吃第"+baoZi+"个包子");
            baoZi++;
        }
    }
    
    public static void main(String[] args) {
        
        Thread3 t1=new Thread3("超级张三线程");
        
        Thread t11=new Thread(t1);
        Thread t12=new Thread(t1);
        Thread t13=new Thread(t1);
        // 实现资源共享
        t11.start();
        t12.start();
        t13.start();
    }
    
}

总结： Runnable接口 可以实现资源共享  而Thread不能。

三、线程状态

四、多线程常用的方法

举例代码如下：

package com.learn.chap08.sec04;

public class Demo1 implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            // 获取当前线程
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+":"+i);
        }
        
    }
    
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        new Thread(demo1).start();
        new Thread(demo1,"线程一").start();
        new Thread(demo1,"线程二").start();
        
        Thread it = new Thread(demo1);
        System.out.println(it.isAlive());
        it.start();
        System.out.println(it.isAlive());
    }

}

运行结果

false
true
Thread-1:0
Thread-1:1
Thread-1:2
Thread-1:3
Thread-1:4
Thread-1:5
Thread-1:6
Thread-1:7
Thread-1:8
Thread-1:9
线程二:0
线程二:1
线程二:2
线程二:3
线程二:4
线程二:5
线程二:6
线程二:7
线程二:8
线程二:9
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-0:5
Thread-0:6
Thread-0:7
Thread-0:8
Thread-0:9
线程一:0
线程一:1
线程一:2
线程一:3
线程一:4
线程一:5
线程一:6
线程一:7
线程一:8
线程一:9

package com.learn.chap08.sec04;

public class Demo2 implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000); // 线程休眠
                // 获取当前线程
                Thread t=Thread.currentThread();
                System.out.println(t.getName()+":"+i);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
    }
    
    public static void main(String[] args) {
        Demo2 demo1 = new Demo2();
        new Thread(demo1).start();
        new Thread(demo1,"线程一").start();
    }

}

运行结果

Thread-0:0
线程一:0
Thread-0:1
线程一:1

.

.

.

package com.learn.chap08.sec04;

public class Demo3 implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            // 获取当前线程
            Thread t=Thread.currentThread();
            System.out.println(t.getName()+":"+i);
            
        }
        
    }
    
    public static void main(String[] args) {
        Demo3 demo1 = new Demo3();
        Thread t1 = new Thread(demo1,"线程一");
        Thread t2 = new Thread(demo1,"线程二");
        Thread t3 = new Thread(demo1,"线程三");
        t1.setPriority(Thread.MAX_PRIORITY); // 更改线程的优先级
        t2.setPriority(Thread.NORM_PRIORITY);
        t3.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    }

}

package com.learn.chap08.sec04;

public class Demo4 implements Runnable{

    @SuppressWarnings("static-access")
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
                // 获取当前线程
                Thread t=Thread.currentThread();
                System.out.println(t.getName()+":"+i);
                if(i==5){
                    System.out.println("线程礼让：");
                    Thread.currentThread().yield();// 出现@SuppressWarnings("static-access")
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        Demo4 demo1 = new Demo4();
        Thread t1 = new Thread(demo1,"线程一");
        Thread t2 = new Thread(demo1,"线程二");
        t1.start();
        t2.start();
    }

}

运行结果

线程一:0
线程二:0
线程一:1
线程二:1
线程一:2
线程二:2
线程二:3
线程一:3
线程一:4
线程二:4
线程一:5
线程礼让：
线程二:5
线程礼让：
线程一:6
线程二:6
线程一:7
线程二:7
线程一:8
线程二:8
线程一:9
线程二:9

五、线程同步
1. 同步方法
2. 同步锁(锁机制)

 上下代码：

package com.learn.chap08.sec05;

public class Demo2 implements Runnable{

    private int baoZi=10;
    
    @Override
    /**
     * 同步方法
     */
    public synchronized void run() { // 用synchronized标识 的方法为同步方法  不加锁的话，下面的张三、李四、王五可能会同时进入run()方法
        // TODO Auto-generated method stub
        while(baoZi>0){
            System.out.println(Thread.currentThread().getName()+"吃了第"+baoZi+"个包子");
            baoZi--;
        }
    }
    
    public static void main(String[] args) {
        Demo2 demo1=new Demo2();
        new Thread(demo1,"张三").start();
        new Thread(demo1,"李四").start();
        new Thread(demo1,"王五").start();
    }

}

package com.learn.chap08.sec05;

public class Demo3 implements Runnable{

    private int baoZi=10;
    
    @Override
    public void run() {
        /**
         * 同步块
         */
        synchronized (this) { // 同步块
            while(baoZi>0){
                System.out.println(Thread.currentThread().getName()+"吃了第"+baoZi+"个包子");
                baoZi--;
            }
        }
    }
    
    public static void main(String[] args) {
        Demo3 demo1=new Demo3();
        new Thread(demo1,"张三").start();
        new Thread(demo1,"李四").start();
        new Thread(demo1,"王五").start();
    }

}

下面举例：java synchronized同步方法调用另一个同步方法，锁机制问题

public synchronized void methodA(int a, int b);

public synchronized void methodB(int a）{
    methodA(a, 0);
}

要明白两个问题，1.锁的对象是谁，2.谁持有了锁。
假设方法A和B是在同一个类Test中的两个方法。
Test t=new Test();
t.methodB();
这个时候，methodB方法被调用时，因为加了synchronized ，需要先获得一个锁，这个锁的对象应该是t，也就是当前的这个Test类的实例，而获得锁的东西是线程，也就是说当前线程拿到了t的锁（而不是你说的B方法获得锁），这个时候B方法内调用methodA，因为A也加了synchronized，也需要获得一个锁，因为A和B都是Test类中的方法，所以当前线程要获得的锁的对象也是t。由于当前线程在执行B方法时已经持有了t对象的锁，因此这时候调用methodA是没有任何影响的，相当于方法A上没有加synchronized。

另一种情况：假设现在有两个Test类
Test t1=new Test();
Test t2=new Test();
t1.methodB();//此时当前线程持有了t1对象的锁
t2.methodB();//此时当前线程也持有了t2对象的锁
当前线程持有了两把锁，锁的对象分别是两个不同的Test类的实例t1和t2，互相没有影响。

再一种情况：假设在多线程环境下，两个线程都可以访问Test t=new Test();
此时假设thread1里调用t.methodB();同时thread2里调用t.methodB()

这时假设thread1先抢到t对象的锁,那么thread2需要等待thread1释放t对象的锁才可以执行B方法。
结果像这样：
thread1获得t的锁--thread1执行methodB--thread1执行methodA--释放t的锁---thread2获得t的锁--thread2执行methodB--thread2执行methodA--释放t的锁。

synchronized还有很多种使用方法，但只有明白是那条线程获得哪个对象的锁，就很容易明白了。

2016年10月31号偶然看到了crossoverjie整理的多线程知识点(原文链接：http://www.jianshu.com/p/72d53d4f833a)，感觉不错，于是在这顺便记录下，补充下知识，呵呵！

进程与线程的区别

进程

进程简单的来说就是在内存中运行的应用程序，一个进程可以启动多个线程。
比如在windows中一个运行EXE文件就是一个进程。

线程

同一进程内的线程共享此进程的地址空间，同时共享进程所拥有的内存和其他资源。

--------------------------------------------------------------------------------------------------

线程Demo-继承Thread类

首先我们我们继承java.lang.Thread类来创建线程。

package top.crosssoverjie.study.Thread;

public class TestThread {
    public static void main(String[] args) {
        System.out.println("主线程ID是：" + Thread.currentThread().getId());
        MyThread my = new MyThread("线程1");
        my.start() ;

        MyThread my2 = new MyThread("线程2") ;
        /**
         * 这里直接调用my2的run()方法。
         */
        my2.run() ;
    }

}

class MyThread extends Thread {
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("名字：" + name + "的线程ID是="
                + Thread.currentThread().getId());
    }

}

输出结果：

主线程ID是：1
名字：线程2的线程ID是=1
名字：线程1的线程ID是=9

由输出结果我们可以得出以下结论：

• my和my2的线程ID不相同，my2和主线程ID相同。说明直接调用run()方法不会创建新的线程，而是在主线程中直接调用的run()方法,和普通的方法调用没有区别。
• 虽然my的start()方法是在my2的run()方法之前调用，但是却是后输出内容，说明新建的线程并不会影响主线程的执行。

----------------------------------------------------------------------------------------------------

线程Demo-实现Runnable接口

除了继承java.lang.Thread类之外，我们还可以实现java.lang.Runnable接口来创建线程。

package top.crosssoverjie.study.Thread;

public class TestRunnable {
    public static void main(String[] args) {
        System.out.println("主线程的线程ID是"+Thread.currentThread().getId());
        MyThread2 my = new MyThread2("线程1") ;
        Thread t = new Thread(my) ;
        t.start() ;

        MyThread2 my2 = new MyThread2("线程2") ;
        Thread t2 = new Thread(my2) ;
        /**
         * 方法调用，并不会创建线程，依然是主线程
         */
        t2.run() ;
    }
}

class MyThread2 implements Runnable{
    private String name ;
    public MyThread2(String name){
        this.name = name ;
    }

    @Override
    public void run() {
        System.out.println("线程"+name+"的线程ID是"+Thread.currentThread().getId());
    }


}

输出结果：

主线程的线程ID是1
线程线程2的线程ID是1
线程线程1的线程ID是9

notes:

• 实现Runnable的方式需要将实现Runnable接口的类作为参数传递给Thread，然后通过Thread类调用Start()方法来创建线程。
• 这两种方式都可以来创建线程，至于选择哪一种要看自己的需求。直接继承Thread类的话代码要简洁一些，但是由于java只支持单继承，所以如果要继承其他类的同时需要实现线程那就只能实现Runnable接口了，这里更推荐实现Runnable接口。

实际上如果我们查看Thread类的源码我们会发现Thread是实现了Runnable接口的：

线程中常用的方法：

方法详解- public static void sleep(long mills)

package top.crosssoverjie.study.Thread;

public class TestSleep {

    private int i = 10 ;
    private Object ob = new Object() ;

    public static void main(String[] args) {
        TestSleep t = new TestSleep() ;
        MyThread3 thread1 = t.new MyThread3() ;
        MyThread3 thread2 = t.new MyThread3() ;
        thread1.start() ;
        thread2.start() ;
    }

    class MyThread3 extends Thread{
        @Override
        public void run() {
            synchronized (ob) {
                i++ ;
                System.out.println("i的值："+i);
                System.out.println("线程："+Thread.currentThread().getName()+"进入休眠状态");
                try {
                    Thread.currentThread().sleep(1000) ;
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("线程："+Thread.currentThread().getName()+"休眠结束");
                i++;
                System.out.println("i的值>："+i);
            }
        }
    }

}

输出结果：

i的值：11
线程：Thread-0进入休眠状态
线程：Thread-0休眠结束
i的值>：12
i的值：13
线程：Thread-1进入休眠状态
线程：Thread-1休眠结束
i的值>：14

由输出结果我们可以得出：

     当Thread0进入休眠状态时，Thread1并没有继续执行，而是等待Thread0休眠结束释放了对象锁，Thread1才继续执行。
     当调用sleep()方法时，必须捕获异常或者向上层抛出异常。当线程休眠时间满时，并不一定会马上执行，因为此时有可能CPU正在执行其他的任务，所以调用了sleep()方法相当于线程进入了阻塞状态。

方法详解- public static void yield()

package top.crosssoverjie.study.Thread;

public class Testyield {
    public static void main(String[] args) {
        MyThread4 my = new MyThread4() ;
        my.start() ;
    }
}
class MyThread4 extends Thread{
    @Override
    public void run() {
        long open = System.currentTimeMillis();
        int count= 0 ;
        for(int i=0 ;i<1000000;i++){
            count= count+(i+1);
//            Thread.yield() ;
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-open)+"毫秒");
    }
}

输出结果:
用时：1毫秒
如果将 Thread.yield()注释取消掉，输出结果:
用时：116毫秒

总结：

• 调用yield()方法是为了让当前线程交出CPU权限，让CPU去执行其他线程。它和sleep()方法类似同样是不会释放锁。但是yield()不能控制具体的交出CUP的时间。并且它只能让相同优先级的线程获得CPU执行时间的机会。
• 调用yield()方法不会让线程进入阻塞状态，而是进入就绪状态，它只需要等待重新获取CPU的时间，这一点和sleep()方法是不一样的。

方法详解- public final void join()

在很多情况下我们需要在子线程中执行大量的耗时任务，但是我们主线程又必须得等待子线程执行完毕之后才能结束，这就需要用到 join()方法了。join()方法的作用是等待线程对象销毁，如果子线程执行了这个方法，那么主线程就要等待子线程执行完毕之后才会销毁，请看下面这个例子：

package top.crosssoverjie.study.Thread;

public class Testjoin {
    public static void main(String[] args) throws InterruptedException {
        new MyThread5("t1").start() ;
        for (int i = 0; i < 10; i++) {
            if(i == 5){
                MyThread5 my =new MyThread5("t2") ;
                my.start() ;
                my.join() ;
            }
            System.out.println("main当前线程："+Thread.currentThread().getName()+" "+i);
        }
    }
}
class MyThread5 extends Thread{

    public MyThread5(String name){
        super(name) ;
    }
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("当前线程："+Thread.currentThread().getName()+" "+i);
        }
    }
}

输出结果：

main当前线程：main 0
当前线程：t1 0
当前线程：t1 1
main当前线程：main 1
当前线程：t1 2
main当前线程：main 2
当前线程：t1 3
main当前线程：main 3
当前线程：t1 4
main当前线程：main 4
当前线程：t2 0
当前线程：t2 1
当前线程：t2 2
当前线程：t2 3
当前线程：t2 4
main当前线程：main 5
main当前线程：main 6
main当前线程：main 7
main当前线程：main 8
main当前线程：main 9


如果我们把join()方法注释掉之后：

main当前线程：main 0
当前线程：t1 0
main当前线程：main 1
当前线程：t1 1
main当前线程：main 2
当前线程：t1 2
main当前线程：main 3
当前线程：t1 3
main当前线程：main 4
当前线程：t1 4
main当前线程：main 5
main当前线程：main 6
main当前线程：main 7
main当前线程：main 8
main当前线程：main 9
当前线程：t2 0
当前线程：t2 1
当前线程：t2 2
当前线程：t2 3
当前线程：t2 4

由上我们可以得出以下结论：

• 在使用了join()方法之后主线程会等待子线程结束之后才会结束。

方法详解- setDaemon(boolean on),getDaemon()

用来设置是否为守护线程和判断是否为守护线程。
notes：

• 守护线程依赖于创建他的线程，而用户线程则不需要。如果在main()方法中创建了一个守护线程，那么当main方法执行完毕之后守护线程也会关闭。而用户线程则不会，在JVM中垃圾收集器的线程就是守护线程。

优雅的终止线程

有三种方法可以终止线程，如下：

1. 使用退出标识，使线程正常的退出，也就是当run()方法完成后线程终止。
2. 使用stop()方法强行关闭，这个方法现在已经被废弃，不推荐使用
3. 使用interrupt()方法终止线程。

具体的实现代码我将在下一篇博文中将到。。

线程的优先级

在操作系统中线程是分优先级的，优先级高的线程CPU将会提供更多的资源，在java中我们可以通过setPriority(int newPriority)方法来更改线程的优先级。
在java中分为1~10这个十个优先级，设置不在这个范围内的优先级将会抛出IllegalArgumentException异常。
java中有三个预设好的优先级：

• public final static int MIN_PRIORITY = 1;
• public final static int NORM_PRIORITY = 5;
• public final static int MAX_PRIORITY = 10;

 

java多线程思维图：