java-线程实验

最新推荐文章于 2023-12-06 00:00:00 发布
最新推荐文章于 2023-12-06 00:00:00 发布
阅读量229 收藏
点赞数
分类专栏： java-编码笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xie__jin__cheng/article/details/108272595
版权

1.线程的创建-继承和接口实现的不同

1.1 接口

1.1.1 代码 

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        MyThread mt1 = new MyThread("线程A ") ;    // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
}
class MyThread implements Runnable{ // 实现Runnable接口，作为线程的实现类
    private String name ;       // 表示线程的名称
    public MyThread(String name){
        this.name = name ;      // 通过构造方法配置name属性
    }
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};

1.1.2 运行结果

Hello World!
线程A 运行，i = 0
线程A 运行，i = 1
线程A 运行，i = 2
线程A 运行，i = 3
线程B 运行，i = 0
线程A 运行，i = 4
线程B 运行，i = 1
线程B 运行，i = 2
线程B 运行，i = 3
线程B 运行，i = 4

1.2 继承实现 

1.2.1 代码

package xjc.com.testroot2;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        MyThread mt1 = new MyThread("线程A ") ;    // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
}
class MyThread extends Thread{  // 继承Thread类，作为线程的实现类
    private String name ;       // 表示线程的名称
    public MyThread(String name){
        this.name = name ;      // 通过构造方法配置name属性
    }
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};

1.2.2 运行结果 

Hello World!
线程A 运行，i = 0
线程A 运行，i = 1
线程A 运行，i = 2
线程A 运行，i = 3
线程B 运行，i = 0
线程A 运行，i = 4
线程B 运行，i = 1
线程B 运行，i = 2
线程B 运行，i = 3
线程B 运行，i = 4

1.3 继承和接口实现的差别

1.3.1代码

package xjc.com.testroot2;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
    	App app = new App();
    	app.main1();
    	try {
    		Thread.sleep(5000);
    	}catch(Exception e){
    		
    	}
    	app.main2();
    }
    public void main1() {
    	System.out.println( "Hello World!" );
        MyThread1 mt1 = new MyThread1("线程A ") ;    // 实例化对象
        MyThread1 mt2 = new MyThread1("线程B ") ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
    public void main2() {
    	System.out.println( "Hello World!" );
        MyThread2 mt1 = new MyThread2("线程A ") ;    // 实例化对象
        MyThread2 mt2 = new MyThread2("线程B ") ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
}
class MyThread1 implements Runnable{ // 实现Runnable接口，作为线程的实现类
    private String name ;       // 表示线程的名称
    private int num;
    public MyThread1(String name){
        this.name = name ;      // 通过构造方法配置name属性
    }
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println(name + "运行，i = " + i+"  num:"+num++) ;
        }
    }
};

class MyThread2 extends Thread{  // 继承Thread类，作为线程的实现类
    private String name ;       // 表示线程的名称
    private int num;
    public MyThread2(String name){
        this.name = name ;      // 通过构造方法配置name属性
    }
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println(name + "运行，i = " + i+"  num:"+num++) ;
        }
    }
};

运行效果

Hello World!
线程A 运行，i = 0  num:0
线程B 运行，i = 0  num:0
线程A 运行，i = 1  num:1
线程B 运行，i = 1  num:1
线程A 运行，i = 2  num:2
线程B 运行，i = 2  num:2
线程B 运行，i = 3  num:3
线程B 运行，i = 4  num:4
线程A 运行，i = 3  num:3
线程A 运行，i = 4  num:4
Hello World!
线程A 运行，i = 0  num:0
线程A 运行，i = 1  num:1
线程B 运行，i = 0  num:0
线程B 运行，i = 1  num:1
线程B 运行，i = 2  num:2
线程B 运行，i = 3  num:3
线程B 运行，i = 4  num:4
线程A 运行，i = 2  num:2
线程A 运行，i = 3  num:3
线程A 运行，i = 4  num:4

1.3 对比2

1.3.1 代码

package xjc.com.testroot2;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
    	App app = new App();
    	app.main1();
    	try {
    		Thread.sleep(5000);
    	}catch(Exception e){
    		
    	}
    	app.main2();
    }
    public void main1() {
    	System.out.println( "Hello World!" );
    	MyThread1 my = new MyThread1();
        Thread mt1 = new Thread(my) ;    // 实例化对象
        Thread mt2 = new Thread(my) ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
    public void main2() {
    	System.out.println( "Hello World!" );
    	MyThread2 my = new MyThread2();
        Thread mt1 = new Thread(my) ;    // 实例化对象
        Thread mt2 = new Thread(my) ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
}
class MyThread1 implements Runnable{ // 实现Runnable接口，作为线程的实现类
    private int num;
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println( "num:"+num++) ;
        }
    }
};

class MyThread2 extends Thread{  // 继承Thread类，作为线程的实现类
    private int num;
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println(" num:"+num++) ;
        }
    }
};

 1.3.2 运行效果

Hello World!
num:0
num:2
num:3
num:4
num:1
num:5
num:6
num:7
num:8
num:9
Hello World!
 num:0
 num:2
 num:3
 num:4
 num:5
 num:1
 num:6
 num:7
 num:8
 num:9

发现也没有什么区别

1.3 对比结论

通过上面的对比，我们发现根本没有什么实质的差别，看下面的观点

实际上 Thread 类和 Runnable 接口之间在使用上也是有区别的，
如果一个类继承 Thread类，则不适合于多个线程共享资源，
而实现了 Runnable 接口，就可以方便的实现资源的共享。

其实上面强调的差别，只是用法的差别，并不是继承和实现接口的差别。

接口的写法 

MyThread2 m=new MyThread2();  
            new Thread(m).start();  
            new Thread(m).start();

继承的写法 

new MyThread().start();  
            new MyThread().start();

 这本来就是两个不同的写法，确用来说明其差别，根据没有意义。更容易误导。

2 同步以及死锁

2.1 未使用同步锁的结果

2.1.1 代码

package xjc.com.testroot2;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
    	App app = new App();
    	app.main1();
    	try {
    		Thread.sleep(7000);
    	}catch(Exception e){
    		
    	}
    	app.main2();
    }
    public void main1() {
    	System.out.println( "Hello World!" );
    	MyThread1 my = new MyThread1();
        Thread mt1 = new Thread(my) ;    // 实例化对象
        Thread mt2 = new Thread(my) ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
    public void main2() {
    	System.out.println( "Hello World!" );
    	MyThread2 my = new MyThread2();
        Thread mt1 = new Thread(my) ;    // 实例化对象
        Thread mt2 = new Thread(my) ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
}
class MyThread1 implements Runnable{ // 实现Runnable接口，作为线程的实现类
    private int num;
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println( "num:"+num++) ;
            try {
        		Thread.sleep(800);
        	}catch(Exception e){
        		
        	}
        }
    }
};

class MyThread2 extends Thread{  // 继承Thread类，作为线程的实现类
    private int num;
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println(" num:"+num++) ;
            try {
        		Thread.sleep(800);
        	}catch(Exception e){
        		
        	}
        }
    }
};

2.1.2运行结果 

Hello World!
num:0
num:1
num:2
num:2
num:3
num:3
num:4
num:4
num:6
num:5
Hello World!
 num:0
 num:1
 num:2
 num:2
 num:3
 num:3
 num:4
 num:4
 num:5
 num:5

发现有点乱，有些运算未生效，最大值应是0~5*2 = 9，这就是多线程处理数据容易产生的问题。

2.2 使用同步锁

2.2.1 代码

package xjc.com.testroot2;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
    	App app = new App();
    	app.main1();
    	try {
    		Thread.sleep(10000);
    	}catch(Exception e){
    		
    	}
    	app.main2();
    }
    public void main1() {
    	System.out.println( "使用同步锁" );
    	MyThread1 my = new MyThread1();
        Thread mt1 = new Thread(my) ;    // 实例化对象
        Thread mt2 = new Thread(my) ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
    public void main2() {
    	System.out.println( "未使用同步锁" );
    	MyThread2 my = new MyThread2();
        Thread mt1 = new Thread(my) ;    // 实例化对象
        Thread mt2 = new Thread(my) ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
}
class MyThread1 implements Runnable{ // 实现Runnable接口，作为线程的实现类
    private int num;
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
        	synchronized(this) {
        		System.out.println( "num:"+num++) ;
                try {
            		Thread.sleep(800);
            	}catch(Exception e){
            		
            	}
        	}
        }
    }
};

class MyThread2 extends Thread{  // 继承Thread类，作为线程的实现类
    private int num;
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println(" num:"+num++) ;
            try {
        		Thread.sleep(800);
        	}catch(Exception e){
        		
        	}
        }
    }
};

2.2.2 运行效果

使用同步锁
num:0
num:1
num:2
num:3
num:4
num:5
num:6
num:7
num:8
num:9
未使用同步锁
 num:0
 num:1
 num:2
 num:3
 num:4
 num:5
 num:6
 num:6
 num:7
 num:7

发现问题了吧，使用同步锁解决了运算错误的问题。那么锁上了，什么时候开锁呢，这里不涉及到if else依赖数据的处理。但是如果有这些，就会导致，锁了之后永远打不开的情况，锁上之后，再次运行时需要状态的，如果两个现在都不未得到运行的状态，那么程序就产生了死锁。

2.3 死锁

2.3.1 代码

package xjc.com.testroot2;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
    	App app = new App();
    	app.main1();
    	try {
    		Thread.sleep(10000);
    	}catch(Exception e){
    		
    	}
    	app.main2();
    }
    public void main1() {
    	System.out.println( "死锁发生" );
    	MyThread1 my = new MyThread1();
        Thread mt1 = new Thread(my) ;    // 实例化对象
        Thread mt2 = new Thread(my) ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
    public void main2() {
    	System.out.println( "死锁不发生" );
    	MyThread2 my = new MyThread2();
        Thread mt1 = new Thread(my) ;    // 实例化对象
        Thread mt2 = new Thread(my) ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
}
class MyThread1 implements Runnable{ // 实现Runnable接口，作为线程的实现类
    private int num=0;
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
        	synchronized(this) {
        		if(num==0) {
        			System.out.println( "num:"+num++) ;
        		}
                try {
            		Thread.sleep(800);
            	}catch(Exception e){
            		
            	}
        	}
        }
    }
};

class MyThread2 extends Thread{  // 继承Thread类，作为线程的实现类
    private int num;
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<5;i++){
            System.out.println(" num:"+num++) ;
            try {
        		Thread.sleep(800);
        	}catch(Exception e){
        		
        	}
        }
    }
};

2.3.2 运行效果

死锁发生
num:0
死锁不发生
 num:0
 num:1
 num:2
 num:2
 num:3
 num:3
 num:4
 num:5
 num:6
 num:7

这里用了一个最简单，最直接，最暴力的方式设置了一个死锁，目的是告诉大家一个结论，死锁是啥，没啥太深奥的东西，就是该执行的代码进步去了。永远无法执行，这就是死锁。死锁通常是做线程共通控制数据状态，状态间的依赖出问题了，才会导致。这里的目标就是弄明白，什么是死锁。

java多线程实验
06-20
java设计两个线程，一个线程充当电子表，每隔一秒在窗口上显示一下系统时间；另一个线程充当闹钟，每到整点就开始报时，即在窗口显示5次整点提示，同时将第一个线程挂起，报时完毕后再将第一个线程恢复。实验结果如图1-1所示：
[ Java学习 ] 线程实验1
怕什么真理无穷？进一寸有一寸的欢喜~
11-27 298
题目： ------------------------------------------------------------------------------------------------------------------------------------------------- 代码： import java.io.*; import java
java 多线程实验_JAVA线程实验
weixin_39820136的博客
02-20 576
实验11 线程一、实验目的1．线程的概念、线程的生命周期。2．多线程的编程：继承Thread类与使用Runnable接口。3．使用多线程机制实现动画。二、实验要求1．掌握利用JAVA语言编写多线程程序的方法2．掌握线程的调度方法3．掌握多线程环境中GUI程序的编写方法三、实验内容(一)Thread子类的方法实现多线程1．编写KY11_1.java 程序文件，源代码如下。class S...
[ Java学习 ] 线程实验2
怕什么真理无穷？进一寸有一寸的欢喜~
12-04 290
题目： 法一： /* 法一： * 客户作为线程，柜台作为链表里的元素，是共享资源 * 优点：易于模拟客户借贷条件不满足时的停等需求。 * 缺点：不保证客户是按来的先后次序被服务。 */ import java.util.*; public class test { static final int workTime = 5; //银行工
SWUST--Java实验(六) 线程
CasT1R's Blog
07-07 581
public class CaThread implements Runnable { static double sum = 1; static String str = "1!"; static int n = 1; Thread thread;//线程类对象 public CaThread() { thread = new Thread(this);//调用本类对象 t...
武汉理工大学Java多线程实验源码
04-22
这些可能是按照课程进度逐步进阶的多线程实验，每个实验可能包含一个或多个Java类，用于演示和练习不同的多线程技术。例如，CTExp01可能涉及线程的基本创建和启动，CTExp03可能涉及到线程同步和互斥，而CTExp06和...
WHUT-java多线程实验-第三周-文件上传和下载.zip
01-16
在“WHUT-java多线程实验-第三周-文件上传和下载.zip”这个实验中，我们将重点探讨如何在多线程环境中实现文件的上传和下载功能。这个实验基于IntelliJ IDEA开发环境，它是一个流行的Java集成开发环境，提供了丰富的...
操作系统-java多线程实验.pdf
10-04
【操作系统-Java多线程实验】的实验主要涵盖了Java中多线程的创建、互斥与同步的概念及其应用。在Java中，实现多线程有两种方式：继承Thread类或实现Runnable接口。本实验中选择了实现Runnable接口的方式，通过定义...
WHUT-java多线程实验-第一周-继承、多态.zip
01-16
本实验“WHUT-java多线程实验-第一周-继承、多态”是针对武汉理工大学学生的面向对象与多线程课程的一个实践环节，旨在通过IDEA集成开发环境帮助学生深入理解并应用Java中的封装、继承和多线程概念。 1. 封装：封装...
WHUT-java多线程实验-第四周-GUI.zip
01-16
本实验基于WHUT（武汉理工大学）面向对象多线程的教学内容，专注于Java图形用户界面（GUI）在多线程环境下的应用。以下是对这个实验主题的详细解释。 1. **Java多线程**：Java通过`Thread`类和`Runnable`接口支持多...
Java必做实验4线程应用
weixin_62431082的博客
11-23 430
然后先定义了一个String类型的数组month来使后面输出方便，再就是分别定义了synchronized 下的printNumber和printChatrs方法来使两线程同时进行两着主语句相差不大，printChars下定义了一个index来记录访问month的下标，注意一下两线程的输出顺序（再if里面注意判断）。该程序与上一题不同的是运用了线程池，用newFixedThreadPool创建了一个线程数为3的线程池，然后将和第一个程序相同的三个线程任务放进线程池，但运行时仍然是线程异步。
Java线程编程实验
HYK_DJ5201314的博客
04-20 502
Java线程编程实验 一 实验内容 1、编写程序创建5个线程，分别显示5个不同的字符串，用继承Thread类以及实现Runnable接口的两种方式实现。 2、编写一个演示死锁的程序。 3、模拟多个线程并发访问堆栈状态，显示各个状态情况。 二 实验目的 （1）理解多线程的概念 （2）掌握线程的创建方法和任务类 （3）掌握事件分发线程机制 （4）理解线程池的概念及应用 （5）理解线程的同步和异步 三 实验过程 （1）问题分析 1、分别创建3个继承与Thread的类的线程和2个继承与Runnab的线程然后分别命名
Java多线程实验
MAILLIBIN的专栏
10-03 1001
多线程是比较抽象的一个概念，其实多线程是一种运筹，单线程就像一次只干一件事情，一件事情做完再去做接下来的另外一件事，比如先煮饭，等饭熟了再炒菜。而多线程则是饭还在煮着的同时就炒菜，然后饭菜差不多同时好了。这就是充分利用等待的空余时间去同时完成多项任务的一种运筹。 多线程中最重要的两个命令应该是start()和join() start()就是开始一个线程，比如按下电饭煲的开关，开始做菜等
【操作系统】实验——线程的控制（Java）
最新发布
z1076233241的博客
12-06 413
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。
java 多线程实验_java实验7-多线程编程
weixin_42129005的博客
02-12 318
1利用Thread和Runnable创建线程【实验目的】(1)理解用实现Runnable接口的方法实现多线程。(2)掌握线程优先级的设置。(3)加深对线程状态转换的理解。【实验要求】要求一：利用多线程实现旋转的行星要求二：写一个线程SyncDemo。给其设计一个方法publicclassgetNumber()从1開始计数到20停止。当中，设计两个同步线程AThread和BThread，均用...
java 多线程实验
ictluo的专栏
09-29 1171
 //Java 中的线程实验 publicclass ThreadTest {     /**     *通过这个实验来感觉线程的工作方式。主类中的     */    public static void main(String[] args) {       // TODO Auto-generated method stub       MyThrea
java多线程实验_Java多线程基本使用
weixin_32966593的博客
02-20 205
关注「实验楼」，每天分享一个项目教程多线程是Java中不可避免的一个重要主体,今天我们就来讲讲它的基本使用。一、概念1.进程1.1进程：是一个正在进行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。1.2线程：就是进程中一个独立的控制单元，线程在控制着进程的执行，一个进程中至少有一个线程。1.3举例java VM：Java VM启动的时候会有一个进程java.e...
java多线程简单实验
白驹过隙
04-24 1552
public class MyThread extends Thread { public int x = 0; public void run(){ System.out.println(++x); } }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值