简述Java多线程(一)

JAVA多线程

程序:是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。

进程:是执行程序的一次执行过程,是一个动态的概念,是系统资源分配的单位。

线程是CPU调度和执行的单位。

创建一个新的执行线程有两种方法:一是将一个类声明为Thread子类。这个子类应该重写run方法,编写线程执行体,创建线程对象,调用start()方法启动线程。二是实现Runnable接口;实现run()方法,编写线程执行体;创建线程,调用start()启动线程。

线程开启不一定立即执行,看CPU的调度

创建方法一举例:

public class Threaddemo1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for(int i = 0 ; i < 100 ; i++){
            System.out.println("thread"+i);
        }
    }

    public static void main(String[] args) {
        Threaddemo1 thread = new Threaddemo1();
        thread.start();

        for(int i = 0 ; i < 100 ; i++){
            System.out.println("hello"+i);
        }
    }
}

输出结果是相互交替的,因为是CPU负责调度,每次结果都可能不一样,若把start()换成run()则顺序确定,性质就不同了。

创建方法二举例:

public class TestThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0 ; i < 100 ; i++){
            System.out.println("thread"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread testThread = new TestThread();
        //创建线程对象
        Thread thread = new Thread(testThread);
        thread.start();

        for(int i = 0 ; i < 100 ; i++){
            System.out.println("hello"+i);
        }
    }
}

两种方法稍微有差异,但是以上两段代码输出等效

总结

继承Thread类:子类继承Thread类具备多线程能力;启动线程只需要子类对象.start();不建议使用(避免OOP单继承局限性)

实现Runnable接口:启动线程需要传入目标对象+Thread对象.Strat();推荐使用(避免单继承局限性,灵活方便,方便同一个对象被多个线程使用)

模拟抢票

@Override
public void run() {
    while(true){
        if(Nums <= 0)
            break;
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"--> get the No."+Nums--);
    }
}

重写run(),该段实现每次间隔200毫秒,环境模拟抢票,main()如下

TestThread1 testThread1 = new TestThread1();

new Thread(testThread1,"xiaoming").start();
new Thread(testThread1,"xiaohong").start();
new Thread(testThread1,"huangniu").start();

该demo出现了不安全情况,可能同时出现两个线程抢占一个资源,考虑信号量方面,没有实现互斥。

模拟龟兔赛跑

public class race implements Runnable{

    private static String winner;
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            boolean flag = gameOver(i);
            if (flag) {
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps){
        if(winner != null){
            return true;
        }
        if(steps == 100){
            winner = Thread.currentThread().getName();
            System.out.println("winner is "+winner);
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        race race1 = new race();

        new Thread(race1,"兔子").start();
        new Thread(race1,"乌龟").start();
    }
}

在这个demo中发现,若不建立公共变量,是不会出现抢占资源的情况的。

实现Callable接口(简单了解)

可以定义返回值,可以抛出异常

  1. 需要定义返回值类型
  2. 重写call方法,若获取结果需抛出异常
  3. 创建目标对象
  4. 创建执行服务
  5. 提交执行
  6. 获取结果
  7. 关闭服务

举例一个demo,首先介绍定义的内部类

class WebDownloader{
    public void downloader(String url, String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO Exception,downloader has a problem");
        }
    }
}

该类实现的是将一个url文件下载下来

public class TestCallable implements Callable <Boolean>{
    private String url;
    private String name;
    public TestCallable(String url,String name){
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("download the file named "+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable s = new TestCallable("URL.jpg","wallpaper1.jpg");
        TestCallable s1 = new TestCallable("URL.jpg","wallpaper2.jpg");
        TestCallable s2 = new TestCallable("URL.jpg","wallpaper3.jpg");
        //创建执行服务,线程池
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> rs1 = ser.submit(s);
        Future<Boolean> rs2 = ser.submit(s1);
        Future<Boolean> rs3 = ser.submit(s2);
        //获取结果
        Boolean rt1 = rs1.get();
        Boolean rt2 = rs2.get();
        Boolean rt3 = rs3.get();

        //关闭服务
        ser.shutdown();
    }
}

以上只是简单的应用,将在下面的文章中介绍具体用法。

静态代理

真实对象和代理对象都要实现同一个接口

代理对象要代理真实角色

好处:代理对象可以做很多真实对象做不了的事情;真实对象专注于做自己的事情

interface Marry{
    void HappyMarry();
}
//真实角色
class You implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("its very happy.");
    }
}
//代理角色
class WeddingCompany implements Marry{
    private Marry target;

    public WeddingCompany(Marry target){
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//真实对象结婚
        after();
    }

    private void before(){
        System.out.println("布置");
    }

    private void after(){
        System.out.println("收款");
    }
}

以结婚的过程举例静态代理,其实Thread就是一个代理角色,真实角色则为Runnable

Lambda表达式

为了避免内部类定义过多

(params)-> expression(表达式); (params) -> statement(语句); (params) -> {statements}

函数式接口的定义:

  • 任何接口,如果只包含唯一一个抽象方法,那么他就是函数式接口
  • 对于函数式接口,我们可以通过lambda表达式来创建该接口的对象
like = ()->{
    System.out.println("I like lambda2");
};
like.lambda();

like为接口定义的一个对象,此接口中有一个lambda方法。

interface Ilike{
    void lambda(int a);
}

三种简化写法:

like = (a)->{
    System.out.println("I like lambda"+a);
};

like = a -> {
    System.out.println("I like lambda"+a);
};

like = a -> System.out.println("I like lambda"+a);
like.lambda(520);

Lambda表达式前提是接口为函数式接口;多个参数可以同时去掉参数类型,需要保持同步,需要加小括号;

简化过程其实可以理解为:静态内部类(类中定义static class,重写方法)->局部内部类(类中定义class,重写方法)->匿名内部类(直接new 接口,重写方法,不写内部类名)->Lambda表达式

线程状态

  • 创建状态
  • 就绪状态

start()之后线程进入就绪状态,但不意味着立即调度执行

  • 阻塞状态
  • 运行状态
  • 死亡状态

线程中断或者结束,一旦进入死亡状态,就不能再次启动

Thread常用方法:

方法 作用
setPriority(int newPriority) 更改此线程的优先级。
static void sleep(long millis) 使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行),具体取决于系统定时器和调度程序的精度和准确性。
void join() 等待这个线程死亡。
static void yield() 对调度程序的一个暗示,即当前线程愿意产生当前使用的处理器。
void interrupt() 中断这个线程。
boolean isAlive() 测试这个线程是否活着。
  • 一般来讲线程最好正常停止(利用循环次数,不建议死循环)

  • 建议设置一个标志位

State枚举类型(具有约束,例如定义四季枚举类型:春夏秋冬)

Thread.State state = thread.getState();

线程休眠_sleep

  • sleep指定当前线程阻塞的毫秒数
  • sleep存在异常InterruptedException
  • sleep时间达到后,线程进入就绪状态
  • 可以模拟网络延时,倒计时等
  • 每个对象都有一个锁,sleep不会释放锁
  • sleep() 方法的作用是在指定的毫秒数内让当前“正在执行的线程”休眠(暂停执行)。这个“正在执行的线程”是指 this.currentThread() 返回的线程。
try {
    Thread.sleep(200);
} catch (InterruptedException e) {
    e.printStackTrace();
}

需要抛出异常

模拟网络延时:可以放大问题的发生性(例如上方“模拟抢票”中,设置一定休眠时间,会发现多个线程抢占同一公共资源)

模拟倒计时:

public static void main(String[] args) throws InterruptedException {
    //Date startTime = new Date(System.currentTimeMillis()); //获取系统当前时间
    while(true){
        Thread.sleep(1000);
        Date startTime = new Date(System.currentTimeMillis());
        System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
    }
}

每隔1s输出一下当前时间(Date类的使用)。

线程礼让_yield

  • 让当前正在执行的线程暂停,但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让CPU重新调度,礼让不一定成功
@Override
public void run() {
    System.out.println(Thread.currentThread().getName()+"线程开始执行");
    Thread.yield();
    System.out.println(Thread.currentThread().getName()+"线程停止执行");
}

执行两个线程,结果如下:

0执行,礼让后给1。该结果可能不成功。yield执行后,会让CPU重新调度,重新调度的结果可能是新的也可能是旧的。

线程强制执行_join

合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞(本质插队)

public class testJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("special Thread comes."+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        testJoin t = new testJoin();
        Thread t1 = new Thread(t);
        t1.start();

        for (int i = 0; i < 500; i++) {
            if(i==200){
                t1.join();
            }
            System.out.println("main"+i);
        }
    }
}

结果为,在循环的500中,前200遍历主线程和t1在并行,而在200时,只剩下t1执行,执行完毕后才把资源归还主线程。

后续将在下一节中介绍线程优先级,锁,同步,生产者消费者,线程池,管程等相关问题。

posted @ 2021-04-10 23:33  GaoYuan206  阅读(34)  评论(0编辑  收藏  举报