java多线程学习1

一：多线程简介

进程：每一个进程(程序)都有独立的代码和数据空间（进程上下文）。进程间的切换会有较大的开销，一个进程包括1--n个线程。（进程是资源分配的最小单位）

线程：同一类线程共享代码和数据空间，每一个线程有独立的执行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）

多进程：是指操作系统能同一时候执行多个任务（程序）。

多线程：是指在同一程序中有多个顺序流在执行。

在java中要想实现多线程，主要有两种方式，继承Thread类或者实现Runable接口，至于实现Callable接口方式，不常用

二：实现多线程

　　（1）方式1：继承Thread类

　　不推荐继承Thread类，因为java是单继承，能实现接口使用的不推荐使用继承，并且Thread类也是实现了Runable接口，并且提供了run()方法用于启动线程

package com.bjsxt.thread;

/**
 * Created by Administrator on 2019/3/9.
 */
public class TestThread01 extends Thread{

    /**
     * 线程的入口点
     */
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println("一遍听歌。。。。");
        }
    }

    public static void main(String[] args){
        TestThread01 testThread01=new TestThread01();   //创建对象
        //启动线程，不保证会立即执行，只是创建了个线程，把执行权交给cpu,至于什么时候执行要看cpu调度
        //如果写成testThread01.run()就是普通方法的调用了
        testThread01.start();

        for(int i=0;i<100;i++){
            System.out.println("一遍敲代码。。。");
        }
    }
}

执行结果

案例：同时开启三个线程下载一个网络url图片

　　1、先写一个文件下载的工具类FileUtils

　　

package com.bjsxt.thread;

import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;

/**
 * Created by Administrator on 2019/3/9.
 */
public class FileUtils {

    /**
     *
     * @param url   文件远程url路径
     * @param name  文件保存位置
     */
    public void copyURLFile(String url,String name){
        try(
            //创建文件输入缓冲流，读取文件信息
            BufferedInputStream bis=new BufferedInputStream(new URL(url).openStream());
            //创建文件输出流，写出文件信息
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(name));
         ) {

            byte[] bytes=new byte[1024];
            int len=-1;
            while((len=bis.read(bytes))!=-1){
                bos.write(bytes,0,len);
                bos.flush();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e){
            e.printStackTrace();
        }
    }
}

　　创建线程类，开启下载

package com.bjsxt.thread;

/**
 * Created by Administrator on 2019/3/9.
 */
public class TestThread02 extends Thread {

    private String name;
    private String path;

    public TestThread02(String name, String path) {
        this.name = name;
        this.path = path;
    }

    @Override
    public void run() {
        System.out.println(name);
        FileUtils fileUtils=new FileUtils();
        fileUtils.copyURLFile(path,name);
    }

    public static void main(String[] args){
        TestThread02 testThread01=new TestThread02("11.jpg","https://jiahongdichan.oss-cn-shenzhen.aliyuncs.com/data/2019-01-05/uploads/banner/jpg/59011546679793431.jpg");
        TestThread02 testThread02=new TestThread02("22.jpg","https://jiahongdichan.oss-cn-shenzhen.aliyuncs.com/data/2019-01-05/uploads/banner/jpg/16651546679105625.jpg");
        TestThread02 testThread03=new TestThread02("33.jpg","https://jiahongdichan.oss-cn-shenzhen.aliyuncs.com/data/2019-01-05/uploads/banner/jpg/24221546678934817.jpg");

        testThread01.start();　　//开启线程1
        testThread02.start();　　//开启线程2
        testThread03.start();　　//开启线程3
    }
}

　　（2）方式2：实现Runable接口

package com.bjsxt.thread;

/**
 * Created by Administrator on 2019/3/9.
 */
public class TestThread03 implements Runnable {

    /**
     * 线程入口
     */
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println("一遍听歌。。。。");
        }
    }

    public static void main(String[] args){
        //创线程实现类
        TestThread03 testThread03=new TestThread03();
        //创建代理对象
        Thread thread=new Thread(testThread03);
        //开启线程
        thread.start();
        for(int i=0;i<100;i++){
            System.out.println("一遍敲代码。。。");
        }
    }
}

 　　案例1：抢票，三个线程共享100张票

　　从这个案例可以看到实现Runable接口实现的多线程，可以共享资源。而继承Thread却不行

package com.bjsxt.thread;

/**
 * Created by Administrator on 2019/3/9.
 */
public class TestThread04 implements Runnable {

    private int ticket=100; //总票数，当前线程共享100个票


    @Override
    public void run() {
        while(true){
            if(ticket<0){
                break;
            }
            try {
                Thread.sleep(100);  //线程睡100毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //获取当前线程的名字
            System.out.println(Thread.currentThread().getName()+"->"+ticket--);
        }

    }

    public static void main(String[] args){
        TestThread04 testThread04=new TestThread04();
        new Thread(testThread04,"线程1").start(); //开启线程，该线程的名字为线程1
        new Thread(testThread04,"线程2").start();
        new Thread(testThread04,"线程3").start();
    }
}

执行结果，我们看到输出的有-1，-2，而我们明明控制的当票数小于0，会退出循环，这就是出现了并发访问问题。

 

　　案例2：龟兔赛跑问题

package com.bjsxt.thread;

/**
 * 模拟龟兔赛跑
 */
public class TestThread05 implements Runnable {

    private String successPerson;   //记录胜利者
    
    @Override
    public void run() {
        for(int steps=0;steps<=100;steps++){
            System.out.println(Thread.currentThread().getName()+"->"+steps);    //打印当前步数
            boolean flag=isSuccess(steps);
            if(flag){
                break;
            }
        }
    }

    private boolean isSuccess(int steps){
        if(successPerson!=null){
            return true;
        }else{
            if(steps==100){
                successPerson=Thread.currentThread().getName();
                System.out.println(successPerson);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args){
        TestThread05 testThread05=new TestThread05();
        new Thread(testThread05,"wugui").start();
        new Thread(testThread05,"tuzi").start();
    }
}

　　（3）方式3：实现Callable接口（不重点讲，多线程高级才会用到）

package com.bjsxt.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 模拟龟兔赛跑
 * 第三种实现线程的方式：实现Callable接口,接口的泛型为call()方法的返回值类型
 */
public class TestThread07 implements Callable<Boolean> {

    private String successPerson;   //记录胜利者

    @Override
    public Boolean call()throws Exception {
        for(int steps=0;steps<=100;steps++){
            System.out.println(Thread.currentThread().getName()+"->"+steps);    //打印当前步数
            boolean flag=isSuccess(steps);
            if(flag){
                break;
            }
        }
        return true;
    }

    private boolean isSuccess(int steps){
        if(successPerson!=null){
            return true;
        }else{
            if(steps==100){
                successPerson=Thread.currentThread().getName();
                System.out.println(successPerson);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args)throws Exception{
        TestThread07 testThread05=new TestThread07();
        //创建执行服务
        ExecutorService es= Executors.newFixedThreadPool(2);
        //提交执行
        Future<Boolean> future1=es.submit(testThread05);
        Future<Boolean> future2=es.submit(testThread05);
        //获取结果
        boolean b1=future1.get();
        boolean b2=future2.get();
        //关闭服务
        es.shutdownNow();
    }
}

三：线程的状态

线程有五大状态，分别是：新生状态，就绪状态，运行状态，阻塞状态，死亡状态。

 （1）线程停止

　　方法1：方法体执行完线程自会停止

　　方法2：调用线程（Thread类）提供的stop()/destroy()方法，不推荐，存在问题，已经被废弃

　　方法3：提供一个boolean型的终止变量，当这个变量置为false，则终止线程的运行（可以定期去检查这个变量）

　　

package com.bjsxt.thread.state;

/**
 * 停止线程
 *
 */
public class TestThreadStop01 implements Runnable{

    private boolean flag=true;  //当是true线程才执行


    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println(Thread.currentThread().getName()+"->"+i++);
        }
    }

    /**
     * 改变标记为false
     */
    public void myStop(){
        this.flag=false;
    }

    public static void main(String[] args){
        TestThreadStop01 testThreadStop01=new TestThreadStop01();
        new Thread(testThreadStop01,"线程1").start();
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"->"+i);
        }
        testThreadStop01.myStop();  //改变标识，停止线程
    }
}

（2）sleep方法

　　特点：

　　　　Thread.sleep(1000)当前线程阻塞的毫秒数，sleep可以让线程进入阻塞状态。

　　　　sleep时间达到后线程进入就绪状态。

　　　　sleep阻塞线程时，不会释放锁。

　　　　sleep()方法是Thread类的静态方法，会阻塞所有执行该行代码的线程。

package com.bjsxt;

/**
 * Created by Administrator on 2019/4/8.
 */
public class TestSleep {

    public static void main(String[] args){
        Ticket ticket=new Ticket();
        new Thread(ticket,"线程1").start();
        new Thread(ticket,"线程2").start();
    }

}


class Ticket implements Runnable{

    private int ticketNum=100;  //共有100张票

    @Override
    public void run() {
        while(true){
            if(ticketNum>0){
                try {
                    Thread.sleep(100);
                    System.out.println("第"+--ticketNum+"张票");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                break;
            }
        }

    }
}

（3）yield方法

　　特点：

　　　　Thread.yield() 礼让线程，让当前正在执行线程暂停，不是阻塞线程，而是将线程从运行状态转入就绪状态，让cpu调度器重新进行调度

　　　　yield()方法是Thread类的静态方法，会作用于所有执行该行代码的线程。

package com.bjsxt;

/**
 * Created by Administrator on 2019/4/8.
 */
public class TestYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"start......");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"end......");
    }

    public static void main(String[] args){
        TestYield testYield=new TestYield();
        new Thread(testYield,"线程1").start();
        new Thread(testYield,"线程2").start();
    }
}

（4）join方法

　　特点：join合并线程,待此线程执行完成后，再执行其他线程，其他线程阻塞

　　　　   join(long mm)方法可以传一个参数毫秒数

　　　　  join是成员方法，不是静态方法，当线程对象调用该方法时，会阻塞执行这段代码的线程，等到该线程对象执行完成或者时间到了，会让cpu调度器重新进行调度

package com.bjsxt;

/**
 * Created by Administrator on 2019/4/9.
 */
public class TestJoin {

    public static void main(String[] args){
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<100;i++){
                    System.out.println(Thread.currentThread().getName()+i);
                }
            }
        },"线程a");
        thread.start();

        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<100;i++){
                    System.out.println(Thread.currentThread().getName()+i);
                }
            }
        },"线程b");

        thread2.start();
        for(int i=0;i<100;i++){
            if(i==20){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

（5）获取线程的状态

　　

package com.bjsxt;

/**
 * 测试线程状态
 */
public class TestThreadState {

    public static void main(String[] args){

        Thread thread=new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread.State state=thread.getState();   //获取该线程的当前状态
        System.out.println(state);
        thread.start();
        System.out.println(thread.getState());


    }

}

四：线程的优先级　

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器按照线程的优先级决定应调度哪个线程来执行。
线程的优先级用数字表示，范围从1到10
• Thread.MIN_PRIORITY = 1
• Thread.MAX_PRIORITY = 10
• Thread.NORM_PRIORITY = 5
使用下述方法获得或设置线程对象的优先级。
• int getPriority();
• void setPriority(int newPriority);
优先级的设定建议在start()调用前
注意：优先级低只是意味着获得调度的概率低。并不是绝对先调用优先级高后调用优先级低的线程。

package com.bjsxt;

import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;

/**
 * 测试线程优先级
 */
public class TestPriority {

    public static void main(String[] args){
        MyPriority myPriority=new MyPriority();
        Thread thread1=new Thread(myPriority,"线程a");
        Thread thread2=new Thread(myPriority,"线程b");
        Thread thread3=new Thread(myPriority,"线程c");
        Thread thread4=new Thread(myPriority,"线程d");
        Thread thread5=new Thread(myPriority,"线程e");
        thread1.setPriority(10);
        thread2.setPriority(9);
        thread3.setPriority(8);
        thread4.setPriority(2);
        thread5.setPriority(1);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }

}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority());
    }
}

五：用户线程和守护线程

• 线程分为用户线程和守护线程;
• 虚拟机必须确保用户线程执行完毕;
• 虚拟机不用等待守护线程执行完毕;
• 如后台记录操作日志、监控内存使用等

package com.bjsxt;

/**
 * 手动创建的线程默认都是用户线程
 */
public class TestThreadType {
    public static void main(String[] args){
        Thread thread=new Thread(new God());
        thread.setDaemon(true); //把该线程设置为守护线程
        thread.start();
        new Thread(new You()).start();
    }

}

class You implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("用户线程"+i);
        }
    }
}

class God implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("守护线程在运行。。。");
        }
    }
}

 六：线程中的其他方法

isAlive()　　 判断线程是否还活着,即线程是否还未终止
setName()　 给线程起一个名字
getName() 　获取线程的名字
currentThread() 取得当前正在运行的线程对象，也就是获取自己本身