java-多线程（一）

最新推荐文章于 2023-12-21 13:20:18 发布
最新推荐文章于 2023-12-21 13:20:18 发布
阅读量268 收藏
点赞数
分类专栏： java语言 文章标签： 线程 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sliencr/article/details/72258018
版权

引言
主要介绍多线程的相关概念
进程和线程
线程是依赖于进程而存在的。
A:进程 正在运行的应用程序
B:线程 进程的执行路径，执行单元
多线程的两种方案：
继承Thread类（查看api简单介绍Thread类）：
实现Runable接口：
有关多线程的深入理解，用一个图片来进行说明：
这里写图片描述
(3)多线程的几个问题：
A:启动线程用的是哪个方法
start()
B:start()和run()的区别
start():1.开启线程 2.执行run()方法里面的代码
run():执行的是线程里面执行的代码，并不会开启线程
C:为什么要重写run()
因为每个线程需要执行的代码都是都是不一样的，
我们需要将每个线程自己独立执行的代码写到run()方法中执行
D:线程可以多次启动吗
下面有关开启多线程的两个方法分别用相关代码做一简单的介绍：

//继承Thread类
package com.stu_01;
//继承Thread类（查看api简单介绍Thread类）：
public class MyThread extends Thread{
     @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}
//测试
package com.stu_01;
public class Test {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
    }

}

//实现runable接口
package com.stu_02;
//实现Runable接口：
public class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}
//测试
package com.stu_02;
public class Test {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t = new Thread(mt);
        t.start();
    }
}

以上两个程序运行结果相同，如下：
0
1
2
3
4
5
6
7
8
9
那么，对于多线程的启动和执行过程又是如何进行的呢？
用一个图解进行理解，就用上面所用代码：
这里写图片描述
线程的调度和控制
线程休眠(Thread.sleep(毫秒值))
线程名称（setName(),getName();）
线程的调度及优先级setPriority(10)（注意默认值是5，区间在1-10之间）
什么叫线程优先级：就是设置你抢占cpu执行权抢占到的概率
多线程安全问题
A:是否是多线程环境
B:是否有共享数据
C:是否有多条语句操作共享数据
* 如何解决线程安全问题？？
1.存在多线程的情况
改不了
2.多个线程之间存在共享数据
改不了
3.存在多条语句操作共享数据
可以改变
关于多线程的安全问题，我想用一个生活中的例子进行说明。
即卖票的问题，在这里，你可以选择继承线程或者实现接口两种方式之一，我下面的代码就用继承做一说明。再不加睡眠的情况下，卖票正常进行，但考虑到实际情况，还是需要加上睡眠相对合适，但是当加上睡眠情况后，卖票就不能正常进行，会出现卖到0和-1的情况，这显然是不对的，下面可以用简单代码演示该问题：

package com.stu_06;
public class MyThread extends Thread{
     static int ticket=100;
    @Override
    public void run() {
        while (true) {
            if (ticket>0) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(this.getName()+"正在出售第"+ticket--+"张票");
            }
        }
    }
}
//测试
package com.stu_06;
public class Test {
    public static void main(String[] args) {
        //创建线程
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        MyThread mt3 = new MyThread();
        //给线程命名
        mt1.setName("窗口一");
        mt2.setName("窗口二");
        mt3.setName("窗口三");
        //开启线程
        mt1.start();
        mt2.start();
        mt3.start();    
    }
}

编译运行部分结果：
窗口二正在出售第2张票
窗口三正在出售第1张票
窗口一正在出售第0张票
窗口二正在出售第-1张票
就如同上面所写的这样，这就会出现线程安全问题，那么该如何解决线程安全问题呢？
如何解决多线程安全问题(掌握)
如果线程安全了，线程安全执行效率就低，但是解决线程安全问题还是很有必要的。
A:同步代码块
synchronized(对象) {
需要被同步的代码。
}
1.对象是什么 ？
答：任意对象 ，相当于是一把锁，只要线程进去就把锁锁上
2.需要同步的代码？
答：被线程执行的代码
B:锁对象问题（仅适用于实现runable接口）
a:同步代码块（定义一个抽象类，里面专门定义一个锁）
任意对象
b:同步方法
public synchronized void sellTicket(){同步代码}
this
c:静态同步方法
类的字节码对象
public static synchronized void sellTicket() {
需要同步的代码
}
在这里，仅演示使用b方法解决额线程安全问题，同样是上面相同的代码，加上同步方法后，我们可以看看结果，如下：

package com.stu_08;
/*
    b:同步方法（仅适用于实现runable接口）
            public synchronized void sellTicket(){同步代码}
                this            
 */
public class MyThread implements Runnable{
    static int ticket=100;
    int x=0;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if(x%2==0){
                if (ticket>0) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket--+"张票");
                }  
                }else{
                    sellTicket();
                }   
            }
        }   
    }
    public synchronized void sellTicket(){
        if (ticket>0) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在出售第"+"张票");
        }
    }
}
//测试
package com.stu_08;
//同步代码块（定义一个抽象类，里面专门定义一个锁）
//任意对象
public class Test {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        //创建进程
        Thread mt1 = new Thread(mt);
        Thread mt2 = new Thread(mt);
        Thread mt3 = new Thread(mt);
        //给进程命名
        mt1.setName("窗口一");
        mt2.setName("窗口二");
        mt3.setName("窗口三");
        //启动进程
        mt1.start();
        mt2.start();
        mt3.start();    
    }
}

编译运行后结果如下：（只显示部分结果）
窗口二正在出售第9张票
窗口三正在出售第8张票
窗口一正在出售第7张票
窗口三正在出售第6张票
窗口二正在出售第5张票
窗口三正在出售第4张票
窗口一正在出售第3张票
窗口三正在出售第2张票
窗口二正在出售第1张票
匿名内部类的方式使用多线程
new Thread() {
public void run() {
…
}
}.start();
new Thread(new Runnable(){
public void run() {
…
}
}).start();
对于匿名内部类，做一个简单的案例进行理解
案例：利用匿名内部类，启动多个线程，验证单例设计模式之懒汉式所存在的缺陷，当使用多线程来搞的时候就不单例了。

package com.stu_11;
/*
 * 案例：利用匿名内部类，启动多个线程，验证单例设计模式之懒汉式所存在的缺陷，
          当使用多线程来搞的时候就不单例了。。
 */
public class SingleInstanceStu {
     private SingleInstanceStu(){}
     private static SingleInstanceStu instance=null;
     public static SingleInstanceStu getInstance(){
         try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         if (instance==null) {
            instance=new SingleInstanceStu();
        }    
         return instance;
     }
}
//测试
package com.stu_11;
public class Test {
    public static void main(String[] args) {
        new Thread(){@Override
        public void run() {
    System.out.println(SingleInstanceStu.getInstance());
        }
    }.start();//com.stu_11.SingleInstanceStu@6c0267a
        new Thread(new Runnable() {         
            @Override
            public void run() {
    System.out.println(SingleInstanceStu.getInstance());
            }   }).start();//com.stu_11.SingleInstanceStu@41aff40f
}
}

后面注释会发现在运行结果中会出现两个不同的地址，这也正是在使用单例模式中的懒汉模式时会发生的错误，但是在使用饿汉模式时就不会出现上述情况。
JDK5的Lock锁，我们之前造的所有的锁都没有手动释放锁
lock是一个接口，它的一个实现类是ReentrantLock，因此在定义一个lock锁的时候使用如下方法：
static Lock lock = new ReentrantLock();
加锁：lock.lock();
释放锁：lock.unlock();
可以让我们明确的知道在哪里加锁和释放锁。
为了保证我们创建的锁一定会被释放，用一下代码进行改进
try{….}finally{…..}
对于lock锁，我们仍然用卖票这个例子做一说明：

package com.stu_12;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyThread implements Runnable{
    static int ticket=100;
    //创建一个锁
    Lock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try{
            lock.lock();
            if (ticket>0) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在售第"+ticket--+"张票");      
            }
            }
            finally{
                lock.unlock();
            }
        }   
    }
}
//测试
package com.stu_12;
public class Test {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        //创建线程
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
        //给线程命名
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        //开启线程
        t1.start();
        t2.start();
        t3.start(); 
    }
}

死锁问题
同步嵌套，锁里面套了一个锁，出现同步嵌套
线程等待和唤醒机制
锁对象调用wait()锁对象调用notify()
注意：
wait和sleep的区别
线程等待，在等待的同时释放锁，而sleep（）方法在执行的过程中是不会释放锁的
对于等待唤醒机制，做一个简单的案例：

package com.stu_14;
//定义一个锁
public class MyLock {
    public static final Object obj=new Object(); 
}
//wait的代码
package com.stu_14;
public class WaitThread extends Thread{
    @Override
    public void run() {
        synchronized (MyLock.obj) {
            try {
                MyLock.obj.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        System.out.println("我被唤醒了");
    }
}
//唤醒代码
package com.stu_14;
public class NotifyThread extends Thread{
      @Override
    public void run() {
        synchronized (MyLock.obj) {
            MyLock.obj.notify();
        }
    }
}

编译运行代码
我被唤醒了

foreveryyyyyyy
关注
专栏目录
Java经典算法——猴子吃桃
Roger1279的博客
03-22 1199
题目： 某天，一只猴子摘了一堆桃子，它每天吃掉其中的一半再多吃一个，第二天吃剩余的一半再多吃一个······到了第N天只剩下一个桃子，问在第一天时摘了多少桃子？ import java.util.Scanner; public class HZCT_Re { public static void main(String[] args) { int num,d
java多线程卖电影票的三种实现方式
weixin_43860634的博客
10-09 816
java多线程卖电影票的三种实现方式
猴子分桃子
GdMC_HYGG的博客
10-21 291
海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？ public class Test10 { /** 思路：一堆桃子被分5次，上次剩余x个，下次剩余(x-1)/5*4，每次都是4...
Java-多线程（上）
Victor.Chang
04-26 1890
进程与线程的概念进程：操作系统中一个程序的执行周期称为一个进程。在DOS系统的时代，由于其本身就是一个单进程的操作系统，所以在同一时间段上只能够有一个程序执行。后来发展到winodws系统后，我们发现多个程序可以同时执行，所以windows是一个多进程的操作系统。线程：一个程序同时执行多个任务。通常，每一个任务就称为一个线程。与进程相比较，线程更"轻量级"，创建、撤销一个线程比启动一个新进程开销要...
构造方法的用法
yjj1123456的博客
09-29 3173
1、编写一个Java应用程序，该程序中有两个类：Animal 动物类，Zoo 动物园类（主类）。 在动物类中， 定义一个double类型的变量weight 表示重量， 定义一个String类型的变量name 表示名字。 定义一个方法setName(String n)设置变量名称。 定义一个方法setWeight(double w) 设置重量。 定义一个有参构造方法，为weight和name属性赋值。 定义一个输出方法show 输出重量和名字。 要求：在Zoo类中， 创建Animal类的
JAVA面向对象案例实现（电影票问题）
MUZHU55的博客
12-21 549
首先在主函数中定义电影票信息，再通过一个switch语句去进行一个选择（具体函数如下）最后在MovieOperator函数中编辑两个选项中的内容输出，并在主函数中调用输出。在Movie函数中定义以下内容。
Java-多线程线程状态转换图
07-22
多线程线程状态转换图
java-多线程 test
06-11
java-多线程 test
14.java-多线程.md
最新发布
08-18
14.java-多线程
【Java-API-多线程】(02) - 文件
10-09
文章附件；JAVA；多线程；Thread；
【Java-API-多线程】(01) - 文件
10-09
文章附件；JAVA；多线程；Thread；
Java练习1--模拟某电影院三个售票窗口同时出售电影票，一个售票窗口可进行退票的过程
崩坏的芝麻
06-02 7160
面向对象的一个小程序，觉着还不错，记录一下 练习要求： 实验要求： （一）编写一个程序，程序模拟某电影院三个售票窗口同时出售电影票的过程。 1． 电影票顺序出售，程序模拟显示售票的详细过程（如：“窗口X出售编号XXX电影票”）。 2． 三个窗口同时出票，出票间隔采用随机控制。 3． 不能重复出售相同的电影票。 程序应具有良好的人机交互性能，即：程序应向用户提示功能说明，并可根据用户的功能选择，执...
java 练习-多线程 章节练习题及面试题
qq_41048982的博客
11-03 4250
java中有几种方法可以实现一个线程(jdk5.0之前)？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？ 答： 有两种实现方法，分别是继承Thread类与实现Runnable接口。 用synchronized关键字修饰同步方法，反对使用stop()，是因为它不安全。 它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。 suspend()方法容易发生死锁。调用suspend()的时候
面向对象基础6
weixin_30710457的博客
09-15 185
编写一个Java应用程序，该应用程序包括2个类：Print类和主类E。Print 类里有一个方法output()功能是输出100 ~ 999之间的所有水仙花数（各位数字的 立方和等于这个三位数本身，如: 371 = 33 + 73 + 13。）在主类E的main方法中来 测试类Print。 转载于:https://www.cnblogs.com/Levi1995/p/5875513.ht...
《Java 2 实用教程》课程学习(12)——第12章 Java 多线程机制
qq_34573534的博客
04-09 1671
进程与线程 进程 动态性：存放在磁盘中的eclipse和QQ并不是进程，双击执行文件，运行之后，这才称为进程。 脱了进程谈论线程就没有什么意义。 线程 进程与线程 线程是系统中最小的执行单元。 同一进程有多个线程。 线程共享进程的资源。 线程的交互 线程需要通信才能正确的工作，这种通信，我们称为线程的交互。 交互的方式包括互斥与同步。 ...
java多线程三种方式区别，java多线程，线程同步方式，线程同步加锁的方法，wait与sleep区别
猴子哥哥的博客
11-21 1795
java多线程三种方式区别 1）实现Runnable接口         定义线程类，实现Runnable接口，重写其public void run（），将此类的对象当做Thread类的构造函数中的参数        所有子线程公用一套run中代码 2）继承Thread类         所有子线程各有一套自己的run代码 3）使用ExecutorService,Cal
Java-多线程（面试题）
zym_1321的博客
06-29 98
1、创建线程的方式 两种： 1）继承Thread类 2）实现Runnable接口 2、多线程的作用 1）发挥多核CPU的优势 2）防止阻塞 3）便于建模 3、start()方法和run()方法的区别 只有调用了start()方法，才会表现出多线程的特性，不同线程的run()方法里面的代码交替执行。如果只是调用run()方法，那么代码还是同步执行的，必须等待一个线程的run()方法里面的代码全部执行...
110923-猴子分桃子问题
宝贝Bear
09-23 2103
110923- 这个问题之前在一本书上看过，可是没有明白机理。今天突然又遇见了，姑且先从百度贴吧里整理出来，在接下来的学习和生活中去思考吧。看书学很美吧，接受它，接受自己吧！不过现在还是不懂得哟！   1979年,诺贝尔奖获得者李政道教授到中国科技大学讲学,他给少年班的同
线程经典实例——吃苹果问题
昆仑山神
01-18 3146
自学线程的时候遇到的一个经典案例，贴出来让大家看看: 存在50个苹果,现在有请三个童鞋(小A,小B,小C)上台表演吃苹果。
Java基础：进程与线程详解-多线程并发实践
然而，多线程允许在一个进程中创建多个并发执行的线程，每个线程可以在不同的部分执行代码，提高了程序的并发性和响应性。在Java中，线程是通过继承Thread类或实现Runnable接口创建的。 **多线程应用示例**： 以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值