java 多线程入门

最新推荐文章于 2024-01-30 14:37:20 发布
最新推荐文章于 2024-01-30 14:37:20 发布
阅读量284 收藏 1
点赞数
分类专栏： java 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15797229/article/details/52434034
版权

实现多线程的两种基本方法

  1. 继承Thread类
  2. 实现Runnable接口（优先选择）
public class TestThread1 {
    public static void main(String[] args) {
        Runner1 runner = new Runner1();
        //线程启动
        runner.start();

        //runner.run();     //方法调用
        //线程启动
        Thread thread = new Thread(runner);
        thread.start();

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

//class Runner1 implements Runnable {
class Runner1 extends Thread {
    public void run() {
        for(int i = 0; i < 100; i++) {
            System.out.println("runner1:"+i);
        }
    }
}

一个线程对象启动两个线程

public class TestThread2 {
    public static void main(String[] args) {
        Runner2 r2 = new Runner2();
        //一个线程对象启动两个线程
        Thread t1 = new Thread(r2);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
}

//class Runner1 implements Runnable {
class Runner2 extends Thread {
    public void run() {
        for(int i = 0; i < 100; i++) {
            System.out.println("runner2:"+i);
        }
    }
}

正常终止子线程

public class TestThread3 {
    public static void main(String[] args) {
        Runner3 r3 = new Runner3();
        Thread t = new Thread(r3);
        t.start();
        for(int i = 0; i < 100; i++) {
            if(i % 10 ==0 & i > 0) {
                System.out.println("main:" + i);
            }
        }
        System.out.println("main over");
        r3.shutDown();  //正常终止子线程
    }
}
class Runner3 implements Runnable {
    private boolean flag = true;
    public void run() {
        int i = 0;
        while(flag) {
            System.out.println(" " + i++);
        }
    }

    public void shutDown() {
        flag = false;
    }
}

isAlive()方法测试线程是否存活

public class TestThread4 {
    public static void main(String[] args) {
        Thread t = new Runner5();
        t.start();

        for(int i = 0; i < 50; i++) {
            System.out.println("mainTread:" + i);
        }
    }
}

class Runner5 extends Thread {
    public void run() {
        System.out.println(Thread.currentThread().isAlive()); //线程是否存活
        for(int i = 0; i < 50; i++) {
            System.out.println("subThread:" + i);
        }
    }
}

yield(),join(),interrupt()方法

1 yield()方法:给其他线程可以执行的机会

public class TestYield {
    public static void main(String[] args) {
        MyThread3 t1 = new MyThread3("线程1");
        MyThread3 t2 = new MyThread3("线程2");
        t1.start();
        t2.start();
    }
}

class MyThread3 extends Thread {
    public MyThread3 (String s) {
        super(s);
    }
    public void run() {
        for(int i = 1; i <= 100; i++) {
            System.out.println(getName() + ":"+i);
            if(i % 10 == 0) {
                yield();    //让出CPU，给其他线程执行的机会
            }
        }
    }
}

2 join()方法:将多个线程合并，相当于方法调用

public class TestJoin {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2("abcde");
        myThread2.start();
        try {
            myThread2.join();  //相当于方法调用
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i = 0; i < 10; i++) {
            System.out.println("main:"+i);
        }
    }
}

class MyThread2  extends Thread {
    public MyThread2(String s) {
        super(s);
    }

    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println("MyThread2:"+i);
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

3 interrupt()方法:终止子线程， 该方法比较暴力，建议少用

public class TestInterrupt {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e){}
        myThread.interrupt(); //中断,抛异常,子线程结束
    }
}
class MyThread extends Thread {
    boolean flag = true;
    public void run() {
        while(flag) {
            System.out.println("===" + new Date() + "===");
            try {
                sleep(1000);  //睡眠1秒
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

线程优先级

public class TestPriority {
    public static void main(String[] args) {
        Thread t1 = new Thread(new T1());
        Thread t2 = new Thread(new T2());
        //Thread.MAX_PRIORITY == 10;
        //Thread.MIN_PRIORITY == 1;
        //Thread.NORM_PRIORITY == 5;
        //优先级越高，执行时间越长
        t1.setPriority(Thread.NORM_PRIORITY + 5); //设置优先级为8
        t1.start();
        t2.start();
    }
}

class T1 implements Runnable {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println("T1："+i);
        }
    }
}

class T2 implements Runnable {
    public void run() {
        for(int i = 0; i < 1000; i++) {
            System.out.println("======T2："+i);
        }
    }
}

死锁

//死锁
public class TestDeadLock implements Runnable{
    public int flag = 1;
    static Object o1 = new Object(), o2 = new Object();

    public void run() {
        System.out.println("flag = " + flag);
        if(flag == 1) {
            synchronized (o1) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o2) {
                    System.out.println("1");
                }
            }
        }

        if(flag == 2) {
            synchronized (o2) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1) {
                    System.out.println("2");
                }
            }
        }
    }

    public static void main(String[] args) {
        TestDeadLock td1 = new TestDeadLock();
        TestDeadLock td2 = new TestDeadLock();

        td1.flag = 1;
        td2.flag = 2;

        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);

        t1.start();
        t2.start();
    }
}

生产者消费者问题

//生产者消费者问题
public class ProducerConsumer {
    public static void main(String[] args) {
        SyncStack ss = new SyncStack();
        Producer p = new Producer(ss);
        Consumer c = new Consumer(ss);
        new Thread(p).start();
        new Thread(c).start();
    }
}

//馒头
class WoTou {
    int id;  //标识馒头
    WoTou(int id) {
        this.id = id;
    }

    public String toString() {
        return "WoTou: " + id;
    }
}

//容器
class SyncStack {
    int index = 0;
    WoTou[] arrWT = new WoTou[6];

    //放入馒头
    public synchronized void push(WoTou wt) {
        while(index == arrWT.length) {
            try {
                this.wait();   //当前线程停止，释放锁.要加锁才能调用wait()
            } catch (InterruptedException e) {
                e.printStackTrace();
            }  
        }
        this.notify();  //唤醒一个当前对象的被锁住的线程
        arrWT[index] = wt;
        index++;
    }

    //拿出馒头
    public synchronized WoTou pop() {
        while(index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        index--;
        return arrWT[index];
    }
}

//生产者有一个容器的引用，这样才知道生产出来的馒头放在何处
class Producer implements Runnable {
    SyncStack ss = null;
    Producer(SyncStack ss) {
        this.ss = ss;
    }

    public void run() {
        for(int i = 0; i < 20; i++) {
            WoTou wt = new WoTou(i); //生产馒头
            System.out.println("生产了:" + wt);
            ss.push(wt);
            try {
                Thread.sleep((long)(Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者有一个容器的引用，这样才知道从哪里拿馒头
class Consumer implements Runnable {
    SyncStack ss = null;
    Consumer(SyncStack ss) {
        this.ss = ss;
    }

    public void run() {
        for(int i = 0; i < 20; i++) {
            WoTou wt = ss.pop();  //拿出馒头
            System.out.println("消费了:" + wt);
            //System.out.println(wt.toString());
            try {
                Thread.sleep((long)(Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

面试题

//面试题
public class TT implements Runnable{
    int b = 100;
    public synchronized void m1() throws Exception {
        b = 1000;
        Thread.sleep(5000);
        System.out.println("b = " + b);
    }

    public void m2() {  //在m1()执行时m2()也可以执行
        System.out.println(b);
    }

    public void run() {
        try {
            m1();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
kd_myway
关注
专栏目录
java多线程入门
06-13
### Java多线程入门 #### 一、进程与线程的区别 在理解Java中的多线程之前，我们先来看看进程和线程之间的区别。 - **进程**：进程是程序的一次执行过程，它是系统进行资源分配和调度的一个独立单位。每个进程都...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
Java 多线程入门
qq_43164662的博客
11-22 496
Java 多线程入门，了解多个线程是如何同时进行的。
Java多线程入门超详解(小白也可以看懂的）
qq_41257358的博客
05-10 3067
Java多线程入门超详解(小白也可以看懂的 一、名词详解1.1 进程和线程1.2 并行和并发1.3 同步和异同步1.4 临界资源和临界区二、为什么要用多线程三、线程的五种状态四、Java创建线程的两种方法1、继承Thread类2、实现Runnable接口五、Java线程的常用方法1、wait()和notify()2、sleep()，yield()，join()3、setPriority()六、sy...
java多线程入门例子-第一例
java 菜鸟一枚
09-18 3219
– 认识多线程-1 多线程运行顺序基础举例 多线程数据共享基本例子
Java多线程详解（一）Java多线程入门
刘成
11-27 2288
最近听很多面试的小伙伴说，网上往往是一篇一篇的Java多线程的文章，除了书籍没有什么学习多线程的一系列文章。但是仅仅凭借一两篇文章很难对多线程有系统的学习，而且面试的时候多线程这方面的知识往往也是考察的重点，所以考虑之下决定写一系列关于Java多线程的文章。文章参考了高老师的《Java多线程编程核心技术》。力争使用最短的篇幅把Java多线程的知识作以系统的讲述。 本节思维导图： 思维导图...
Java多线程入门(二)
qq_44525150的博客
06-07 2076
本文简要介绍了Java多线程中的线程同步的作用，实现线程同步的三种方法，什么是线程死锁，线程死锁的例子，线程的状态，线程的生命周期
JAVA多线程使用,从入门到精通,看这一篇打开思路,豁然开朗
最新发布
yyj12138的博客
01-30 832
java多线程;线程创建;线程池;线程池参数;面试八股文;java创建线程的方式;多线程入门;多线程看这一篇就够了
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Java多线程入门篇（三）Java线程间的通信（锁，等待/通知，信号量，管道）
wangdawei_的博客
02-28 846
java多线程入门篇 （三） 锁与同步等待/通知机制信号量：管道：其它通信相关join方法sleep方法ThreadLocal类InheritableThreadLocal   在Java中合理的使用多线程可以更好的利用服务器资源。一般来说，线程都有自己的自由线程上下文，互不干扰。但是当我们需要多个线程之间互相协作的时候，就需要掌握Java线程的通信方式才可以 锁与同步   在Java中锁都是基于对象的，所以又称为对象锁。锁与线程的关系就像婚姻关系，一个锁在同一时间只能由一个线程持有，只有当持有锁的线程释放
002-Java多线程入门学习
qq_40488788的博客
11-24 342
Java多线程入门学习 ​ 狂神说Java多线程模块总结篇-凡人就该保留偏执的权利-kxd@my.swjtu.edu.cn 一.线程，进程，多线程 程
编程必备：JAVA多线程详解
拾一二的博客
06-14 8618
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
java多线程入门知识及示例程序
09-04
"Java多线程入门知识及示例程序" Java多线程是一种非常重要的编程技术，它可以帮助开发者创建高效、可扩展的程序。多线程的出现是为了解决某些问题，如图形界面的出现、输入、输出的阻塞和多核CPU的更好利用等。 ...
java多线程入门的源代码
03-28
Java多线程是Java开发中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当一个类继承了Thread...
java 注解与反射
qq_15797229的博客
01-03 1133
注解可以当做一种接口来看待；注意四个元注解；利用反射可以读取注解的信息和泛型的信息；@Retention(RetentionPolicy.RUNTIME)，注解要设成这样才可以利用反射读取信息
java 动态编译与用Rhino引擎执行javascript代码
qq_15797229的博客
01-03 842
动态编译后可以用RuntTime类动态运行程序，也可以通过URLClassLoader加载编译好的文件，利用反射运行main方法；Rhino引擎用来运行JavaScript脚本，还有其他引擎可以运行pathon等脚本
java 字节码操作（javassist）
qq_15797229的博客
01-04 660
学会用javassist生成类；操作类，属性，构造器，方法，注解等
java 手写服务器
qq_15797229的博客
12-30 658
思路：利用ServerSocket监听客户端；封装好Response和Request；在Dispatcher里面封装一个Response和一个Request，保证多线程；然后抽象Servlet父类；要实现自己的业务，只需要实现Servlet类的doGet()方法和doPost()方法；在这之前，要配置web.xml文件；然后用SAX解析xml文件，用上下文容器存储解析结果；用反射找到对应的ServLet；然后输出。
java 内部类
qq_15797229的博客
01-06 447
内部类分为静态内部类和非静态内部类；非静态内部类分为普通内部类，匿名内部类，方法内部类
Java多线程入门与线程安全
"这篇资料是关于Java多线程的学习材料，由高级软件人才实作培训专家北京传智播客教育提供，由讲师毕向东讲解。资料涵盖了多线程的基础概念，如进程、线程的创建与状态，以及线程安全问题和同步机制。" Java多线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值