java线程基础

最新推荐文章于 2023-04-15 16:15:07 发布
最新推荐文章于 2023-04-15 16:15:07 发布
阅读量190 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fendam/article/details/79439768
版权

Java创建线程的方式：

两个线程同时加载一个类字节码的时候，对于JVM而言，天生的线程安全，因为类字节码只能加载一次，当第二次加载时会直接跳过

  1.  继承java.lang.Thread

    线程启动后，必须执行run方法（run方法运行完就结束） 

public class TestThread1 extends Thread{

    @Override
    public void run() {
        while(true){
         System.out.println("Thread1");
        }
    }
}

main方法： 
@Test
public void Test1(){
    TestThread1 t1 = new TestThread1();//t1就是一个线程，因为继承了Thread
    t1.start();//如果改成t1.run()的话就会变成单线程,只会执行t1中的方法
    while(true){   //再创建一个
        System.out.println("main方法");
    }

}

        2.  实现Runable接口（建议使用这种方法，因为实现之后还可以继承类） 

public class TestThread2 implements Runnable {

    @Override
    public void run() {
        while(true){
            System.out.println("TestThread2");
        }
    }
}

main方法： 
@Test
public void Test2(){
    TestThread2 t2 = new TestThread2();
    Thread t = new Thread(t2);
    t.start();

    //也可以采用匿名内部类的写法
    Thread t3 = new Thread(
            new Runnable() {
                @Override
                public void run() {
                    while(true){
                        System.out.println("Thread3");
                    }
                }
            }
    );
    t3.start();
}



------------------------手动分隔符=。=-------------------------------------------------------------------------------------------------------

多线程几个常用的方法
Thread.sleep   当前线程休眠一会
getName  返回线程名字
setName  给线程取个名字
interrup()  中断线程
t.join()       等待t进程跑完后再去执行其他的线程
yield()       让别的线程先执行

示例1: 
public class TestThread1 extends Thread{

    @Override
    public void run() {
        while(true){
         System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {  //这个异常是指这个进程正睡着呢，其他进程就把它叫醒
                e.printStackTrace();
            }
        }
    }
}
main方法： 
@Test
public void Test1() throws InterruptedException {
    TestThread1 t1 = new TestThread1();
    t1.setName("t_shiyw");
    t1.setPriority(Thread.MAX_PRIORITY);//Thread.MAX_PRIORITY=10
    t1.start();
    t1.join();  //加上这行就不会执行下面的mian线程
    while(true){
        System.out.println("main线程");
    }

}


------------------------手动分隔符=。=---------------------------------------------------------------------------------------------------

怎么处理线程安全
synchronized
锁就是一个对象
如果和static在一起，那么这个锁，就是Test.class(Test类字节码，在java虚拟机中独一份)
如果没有static，那么这个锁就是new出来的实力对象
示例1: 
public class TestThread2 implements Runnable {

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {  //这个异常是指这个进程正睡着呢，其他进程就把它叫醒
            e.printStackTrace();
        }
        TestThread.i = TestThread.i+1;
    }
}

main方法： 
ublic class TestThread {

    public static int i = 0;

    @Test
    public void Test1() throws InterruptedException {
        TestThread2 t = new TestThread2();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        Thread t5 = new Thread(t);
        Thread t6 = new Thread(t);
        Thread t7 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        t7.start();
        Thread.sleep(2000);
        System.out.println(i);
    }

}

运行结果：
可能是7，可能是6，可能是5。。。。



如果改成这样： 
public class TestThread2 implements Runnable {

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {  //这个异常是指这个进程正睡着呢，其他进程就把它叫醒
            e.printStackTrace();
        }
        TestThread.add();
    }
}


main方法： 
public class TestThread {

    public static int i = 0;

    @Test
    public void Test1() throws InterruptedException {
        TestThread2 t = new TestThread2();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        Thread t5 = new Thread(t);
        Thread t6 = new Thread(t);
        Thread t7 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        t7.start();
        Thread.sleep(2000);
        System.out.println(i);
    }

    public static synchronized void add() {
        i++;
    }

}

运行结果：
肯定是7


什么时候会有线程安全，几个线程访问同一个对象时。


Java中两个线程是否可以同是否问一个对象的两个不同的synchronized方法？
不可以！！ 多个线程访问同一个类的synchronized方法时, 都是串行执行的 ! 就算有多个cpu也不例外 ! synchronized方法使用了类java的内置锁, 即锁住的是方法所属对象本身. 同一个锁某个时刻只能被一个执行线程所获取, 因此其他线程都得等待锁的释放. 因此就算你有多余的cpu可以执行, 但是你没有锁, 所以你还是不能进入synchronized方法执行, CPU因此而空闲. 如果某个线程长期持有一个竞争激烈的锁, 那么将导致其他线程都因等待所的释放而被挂起, 从而导致CPU无法得到利用, 系统吞吐量低下. 因此要尽量避免某个线程对锁的长期占有 !

示例： 
public class T1 implements  Runnable{
    @Override
    public void run() {
        TestThread3.println1();
    }
}



public class T2 implements  Runnable{
    @Override
    public void run() {
        TestThread3.println2();
    }
}

main方法： 
public class TestThread3 {

    public static void main(String[] args){
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();

    }

    public static synchronized void println1(){
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

    }

    public static synchronized void println2(){
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

    }
}

运行结果：
Thread-1:1
.
.
.
Thread-1:99
Thread-0:1
.
.
.
Thread-0:99

如果将上面TestThread3中的println2方法的static去掉。T2类改成如下： 
public class T2 implements  Runnable{
    @Override
    public void run() {
        TestThread3 t = new TestThread3();
        t.println2();
    }
}

运行结果：
Thread-0和Thread-1交叉执行，不会实现线程同步

原因：
new TestThread3()是一个Object对象,TestThread3.class也是Object对象，但不是同一个对象，一个在堆里面，一个在方法区类加载的时候就有了。
所以加了static抢到的是类字节的锁，不加static，抢到的是实例锁。



------------------------手动分隔符=。=-----------------------------------------------------------------------------------------------------------------
wait  当前线程释放锁，并且进入长期休眠状态，等待别人叫醒
sleep  不会释放锁
notify   唤醒 当前对象上的等待线程，notify唤醒单个线程；notifyAll唤醒所有线程


示例： 
生产者，消费者，馒头，篮子
生产者生产馒头
消费者吃馒头

篮子： 
public class Box {  //因为访问的是同一个篮子，所以要注意线程安全
    private Mantou[] arr = new Mantou[10];//最多10个馒头
    private int i = 0;  //标志现在是哪个馒头

    //放馒头
    public synchronized void set(Mantou mantou){
        while(i>=10){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"生产了"+mantou);
        arr[i] = mantou;
        i++;
        this.notifyAll();
    }

    //吃馒头
    public synchronized  Mantou pop() {
        while(i==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        i--;
        Mantou mantou = arr[i];
        System.out.println(Thread.currentThread().getName()+"消费了"+mantou);
        this.notifyAll();
        return mantou;
    }
}

馒头： 
public class Mantou {
    private String name;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String toString(){
        return this.name;
    }
}

消费者： 
public class Consumer implements  Runnable {

    private Box box;
    @Override
    public void run() {
        while (true) {
            Mantou mantou = box.pop();
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    }

    public void setBox(Box box) {
        this.box = box;
    }
}


生产者： 
public class Producter implements Runnable {

    private Box box;
    @Override
    public void run() {
        while(true){
            Mantou mantou = new Mantou("馒头"+(int)(Math.random()*100));
            box.set(mantou);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public void setBox(Box box) {   //用set方法告诉他篮子在哪里
        this.box = box;
    }
}

main方法： 
public class Test {
    public static void main(String args[]) {
        Producter p = new Producter();
        Consumer c = new Consumer();
        Box box = new Box();
        p.setBox(box);
        c.setBox(box);
        Thread p1 = new Thread(p);
        p1.setName("生产者1");
        Thread p2 = new Thread(p);
        p2.setName("生产者2");
        Thread p3 = new Thread(p);
        p3.setName("生产者3");
        Thread c1 = new Thread(c);
        c1.setName("消费者1");
        Thread c2 = new Thread(c);
        c2.setName("消费者2");
        Thread c3 = new Thread(c);
        c3.setName("消费者3");
        Thread c4 = new Thread(c);
        c4.setName("消费者4");

        p1.start();
        p2.start();
        p3.start();
        c1.start();
        c2.start();
        c3.start();
        c4.start();

    }
}


运行结果：
生产者1生产了馒头35
生产者3生产了馒头28
生产者2生产了馒头17
消费者1消费了馒头17
消费者2消费了馒头28
消费者3消费了馒头35
生产者3生产了馒头16
消费者3消费了馒头16
生产者1生产了馒头31
消费者4消费了馒头31
生产者2生产了馒头57
消费者2消费了馒头57












Fendam
关注
java 等待5秒_java线程基础知识整理（上）
weixin_42168265的博客
01-21 2525
原文链接：https://blog.csdn.net/weixin_42032770/article/details/107536554?utm_medium=distribute.pc_category.none-task-blog-hot-3.nonecase&depth_1-utm_source=distribute.pc_category.none-task-blog-hot-3....
打印当前线程信息_Java 线程基础，（基础的不能再基础）从这篇开始
weixin_42514711的博客
01-12 2397
线程作为操作系统中最少调度单位，在当前系统的运行环境中，一般都拥有多核处理器，为了更好的充分利用 CPU，掌握其正确使用方式，能更高效的使程序运行。同时，在 Java 面试中，也是极其重要的一个模块。线程简介一个独立运行的程序是一个进程，一个进程中可以包含一个或多个线程，每个线程都有属于自己的一些属性，如堆栈，计数器等等。同时，一个线程在一个时间点上只能运行在一个 CPU 处理器核心上，不同线程之...
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6332
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java线程基础
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
06-14 2511
简介： 线程是操作系统调度的最小单元，在多核环境中，多个线程能同时执行，如果运用得当，能显著的提升程序的性能。 ​ 一、线程初步认识 1、什么是线程 操作系统运行一个程序会为其启动一个进程。例如，启动一个Java程序会创建一个Java进程。现代操作系统调度的最小单元是线程，线程也称为轻量级进程（Light Weight Process），一个进程中可以创建一个到多个线程，线程拥有自己的计数器、堆栈和局部变量等属性，并且能访问共享的内存变量。处理器会通过快速切换这些线程，来执行程序。 ​ 2、Java本身就是
Java基础：Java线程基础
TuT
04-17 3273
操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的...
java线程基础知识总结
星晚的博客
03-04 1万+
本期讲解的是java中关于线程的相关知识点1.创建线程的方式2.线程的优先级3.线程阻塞4.线程的相关方法5.守护线程6.线程池7.多线程并发安全问题7.3静态方法修饰synchronized 1.创建线程的方式 1.1继承Thread类并重写run方法 public class ThreadDemo1 { public static void main(String[] args) { MyThread1 t1 = new MyThread1(); MyThread2 t2 = new My
Java中的线程基础篇-线程基本概念
weixin_44446626的博客
05-08 2072
Java中的线程一、基础知识1. 进程、线程、协程1.1 进程1.2 线程1.3 协程2. 串行、并发、并行2.1 串行2.2 并发2.3 并行二、线程的创建1. 继承Thread类1.1 实现步骤1.2 特点2. 实现Runnable接口2.1 实现步骤2.2 与Thread相比3. 实现Callable接口（JDK5.0新增）3.1 实现步骤3.2 与Runnable接口相比三、线程的常用方法四、线程的生命周期1. 基本概念2. 六个状态 一、基础知识 1. 进程、线程、协程 1.1 进程 基本概念
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java线程系列详解
wang_yong_hui_1234的博客
04-15 5227
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
Java多线程基础（一）
计蒙不吃鱼的博客
07-19 5910
文章分两份，第一份主要内容为1-4点 1.多线程的概念 2.Java程序运行原理 3.实现多线程的2种方式 4.2种方式的区别 5.线程同步（同步锁） 6.同步线程之间的通讯 1.多线程的概念 （1）并发和并行 并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，...
Java线程基础教程完整版
03-14
通过深入学习和实践这些Java线程基础知识，你可以有效地编写出高效、安全的多线程程序。记住，理解线程的原理和掌握同步机制是关键，这将有助于解决复杂的并发问题。阅读"Java线程.pdf"文档，你将获得更详细、全面的...
java-thread：Java线程基础信息
02-07
Java线程基础信息 java线程操作机制 java线程运行机制 通过芯片的速度越来越快，散热也越来越困难。很久都没有看到CPU的原始速度有重大提升了。但我们仍然看到摩尔定律在起作用，CPU的设计者们继续在向每片硅晶上...
2009-2023年上市公司企业客户ESG数据-最新出炉.zip
11-01
2009-2023年上市公司企业客户ESG数据-最新出炉.zip
++i和i++d的区别.docx
11-01
i和i ++i和i++的区别
本文以竞赛心态的调整为开端，以常数时间优化为基础，以数学分析与猜想为指导思想，. 以非完美算法为主要策略，以搜索为最后的万能策略
最新发布
11-01
本文以竞赛心态的调整为开端，以常数时间优化为基础，以数学分析与猜想为指导思想，. 以非完美算法为主要策略，以搜索为最后的万能策略
电调测试程序 https://blog.csdn.net/weixin-45902229/article/details/121
11-01
电调测试程序 https://blog.csdn.net/weixin-45902229/article/details/121
percona-xtrabackup-2.4.28-1.ky10.x86-64.rpm
11-01
xtrabackup银河麒麟v10rpm安装包
Java线程基础与实战
本教程针对已有一定Java基础但对线程处理不太熟悉的开发者，旨在深入讲解Java线程的各个方面。 线程是程序中的执行单元，它们在一个进程中并行运行，每个线程都有自己的程序计数器、堆栈和局部变量，但共享同一内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值