Java多线程

最新推荐文章于 2025-02-14 15:44:02 发布

转载最新推荐文章于 2025-02-14 15:44:02 发布 · 511 阅读

文章标签：

#java设计模式

JAVA 专栏收录该内容

18 篇文章

订阅专栏

本文详细介绍了Java中的多线程实现方式，包括覆盖父类Thread的run方法和实现Runnable接口两种方法。同时，文章阐述了定时器类Timer和TimerTask的使用，以及如何在指定时间间隔后执行任务或循环执行任务。此外，还讨论了Java传统线程互斥技术，如以this作为锁对象、以Outputer.class作为锁对象和以自定义对象作为锁对象的方法。最后，文章讲解了Java传统线程同步通信技术，包括线程间通信的实现方式。

部署运行你感兴趣的模型镜像

1.Java多线程传统实现方式

原链接地址：http://blog.youkuaiyun.com/kingzone_2008/article/details/44571181

public class TraditionalThread {

    public static void main(String[] args) {

        /*
         * 方法1：覆盖父类Thread的run方法
         */
        Thread thread = new Thread() {

            @Override
            public void run() {
                while(true) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("输出1:" +     Thread.currentThread().getName());
                    System.out.println("输出2:" + this.getName());
                }
            }

        };
        thread.start();

        /*
         * 方法2：实现Runnable接口，实现其run方法
         */
        Thread thread2 = new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("输出1:" + Thread.currentThread().getName());
//                  System.out.println("输出2:" + this.getName());
                }
            }

        });
        thread2.start();
  }
}

2.定时器类：Timer类和TimerTask类

原链接地址：http://blog.youkuaiyun.com/kingzone_2008/article/details/45270171

2.1指定时间间隔后执行任务

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TraditionalTimerTest {

    public static void main(String[] args) {

        // 启动定时器线程，并在10000毫秒后执行TimerTask实例的run方法
        new Timer().schedule(new TimerTask() {

            @Override
            public void run() {
                System.out.println("bombing!");

            }
        }, 10000);

        while(true) {
            System.out.println("时钟时间：" + new Date().getSeconds());
            try {
                Thread.sleep(1000);// 主线程每隔1秒钟，打印当前时钟时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

2.2指定时间间隔后循环执行任务

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TraditionalTimerTest {

    public static void main(String[] args) {
        // 启动定时器线程，并在10000毫秒后开始，每隔3000毫秒执行一次定时任务
        new Timer().schedule(new TimerTask() {// 定时任务

            @Override
            public void run() {
                System.out.println("bombing!");

            }
        }, 10000, 3000);

        while(true) {
            System.out.println("时钟时间：" + new Date().getSeconds());
            try {
                Thread.sleep(1000);// 主线程每隔1秒钟，打印当前时钟时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

2.3更灵活地间隔

//定义两个/多个TimerTask类
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TraditionalTimerTest {

    public static void main(String[] args) {

        new Timer().schedule(new MyTimerTask1(), 2000);

        while(true) {
            System.out.println("时钟时间：" + new Date().getSeconds());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
class MyTimerTask1 extends TimerTask {

    @Override
    public void run() {
        System.out.println("Task1");
        new Timer().schedule(new MyTimerTask2(), 2000);// 启动定时任务2
    }

}
class MyTimerTask2 extends TimerTask {

    @Override
    public void run() {
        System.out.println("Task2");
        new Timer().schedule(new MyTimerTask1(), 4000);// 启动定时任务1
    }

}

3.Java传统线程互斥技术

原链接地址：http://blog.youkuaiyun.com/kingzone_2008/article/details/48166731
3.1以this作为锁对象

实现方式
synchronized(this){…}
synchronized实例方法
适用情况
适用于使用类的同一个实例（对象）作为锁对象。下面情况不适用：
若上述代码中第26行和第39行，改为
new Printer().output(“<相应字符串>”);
则无法使用本方法实现线程互斥，而须采用第2种方法。

3.2以Outputer.class作为锁对象

Outputer类的字节码对象由jvm自动加载。
实现方式
synchronized(Outputer.class){…}
static synchronized方法
适用情况
适用于整个类的所有对象都需要互斥访问的情况。

3.3以自定义的对象作为所对象

实现方式
synchronized(<自定义锁对象>){…}
适用情况
同一个类中代码块或者方法的互斥，一般可以用第1种和第2种方法替换。当出现需要在多个类（或者多个类的实例）之间进行互斥控制时，可能需要采用本方法。

3.4一些代码

public class TraditionalThreadSynchronized {

    public static void main(String[] args) {
        new TraditionalThreadSynchronized().foo();
    }

    private void foo() {
        // printer须是final的，否则无法编译。这主要是为了保证printer的一致性。
        final Printer printer = new Printer();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    /* 
                     * Cannot refer to a non-final variable printer
                     * inside an inner class defined in a different method
                     * 更多内容可参阅java8 lambda表达式（闭包）相关知识
                     */
                    printer.output("123456789");
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    printer.output("abcdefghi");
                }
            }
        }).start();
    }

    static class Printer {
        String _lock = "";
        public void output(String name) {
            int len = name.length();
            // 同步代码块

            /* 方法1：
             * 以this作为锁对象，
             * 与使用this加锁的代码块或synchronized方法互斥
             */
            // synchronized(this) {

            /* 方法2：
             * 以Outputer类的字节码对象（该对象由虚拟机自动创建）作为锁对象，
             * 与使用Outputer.class加锁的代码块或static synchronized方法互斥
             */
            // synchronized(Outputer.class) {

            /* 方法3：
             * 以自定义对象作为锁对象，
             * 与使用_lock加锁的代码块互斥
             */
            synchronized(_lock) {
                for(int i=0; i<len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }

        // 同步方法，相当于synchronized(this){}
        public synchronized void output2(String name) {
            int len = name.length();
            for(int i=0; i<len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }

        // 静态同步方法，相当于synchronized(Outputer.class){}
        public static synchronized void output3(String name) {
            int len = name.length();
            for(int i=0; i<len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}

4.Java传统线程同步通信技术

原链接地址：
http://blog.youkuaiyun.com/kingzone_2008/article/details/49853341

public class TraditionalThreadCommunication {

    public static void main(String[] args) {
        // 必须声明为final
        final Business business = new Business();
        new Thread(
                new Runnable() {

                    @Override
                    public void run() {
                        for(int i=1; i<=50; i++) {
                            business.sub(i);
                        }
                    }

                }
                ).start();

        for(int i=1; i<=50; i++) {
            business.main(i);
        }
    }

}

class Business {
    // 该变量用于线程间通信
    private boolean bShouldSub = true;
    public synchronized void sub(int i) {
        if(!bShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for(int j=1; j<=10; j++) {
            System.out.println("sub thread sequence of " 
                                + j + ", loop of " + i);
        }
        bShouldSub = false;
        this.notify();
    }
    public synchronized void main(int i) {
        if(bShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for(int j=1; j<=100; j++) {
            System.out.println("main thread sequence of " 
                                + j + ", loop of " + i);
        }
        bShouldSub = true;//执行完后，将自己wait()
        this.notify();
    }
}