Java中创建线程用第几种方式

2015年11月19日10:16:33

作者:数据分析玩家

//用第一种方法创建线程:每个线程处理的是不同的资源
//每个线程分别对应20张电影票,之间并无任何关系,这就说明每个线程之间是平等的,没有优先级关系
class Tc extends Thread
{
private int tickets = 20;//每个线程各自卖20张票

public String name ;
public Tc(String name)
{
this.name = name;
}
public void run()
{
while(tickets > 0)
{
System.out.printf("%s窗口正在售%d张票\n",name,tickets);
tickets --;
}
}
}
public class zhang3
{
public static void main(String[] args)
{
Tc t1 = new Tc("老人窗口----");
t1.run();//实现一个窗口卖票

Tc t2 = new Tc("-------儿童窗口");
t2.run();//不同的类对象,其属性占用不同的内存空间,这是根本

Tc t3 = new Tc("---中年窗口---");
t3.run();
}
}
/*
运行结果:
老人窗口----窗口正在售20张票
老人窗口----窗口正在售19张票
老人窗口----窗口正在售18张票
老人窗口----窗口正在售17张票
老人窗口----窗口正在售16张票
老人窗口----窗口正在售15张票
老人窗口----窗口正在售14张票
老人窗口----窗口正在售13张票
老人窗口----窗口正在售12张票
老人窗口----窗口正在售11张票
老人窗口----窗口正在售10张票
老人窗口----窗口正在售9张票
老人窗口----窗口正在售8张票
老人窗口----窗口正在售7张票
老人窗口----窗口正在售6张票
老人窗口----窗口正在售5张票
老人窗口----窗口正在售4张票
老人窗口----窗口正在售3张票
老人窗口----窗口正在售2张票
老人窗口----窗口正在售1张票
-------儿童窗口窗口正在售20张票
-------儿童窗口窗口正在售19张票
-------儿童窗口窗口正在售18张票
-------儿童窗口窗口正在售17张票
-------儿童窗口窗口正在售16张票
-------儿童窗口窗口正在售15张票
-------儿童窗口窗口正在售14张票
-------儿童窗口窗口正在售13张票
-------儿童窗口窗口正在售12张票
-------儿童窗口窗口正在售11张票
-------儿童窗口窗口正在售10张票
-------儿童窗口窗口正在售9张票
-------儿童窗口窗口正在售8张票
-------儿童窗口窗口正在售7张票
-------儿童窗口窗口正在售6张票
-------儿童窗口窗口正在售5张票
-------儿童窗口窗口正在售4张票
-------儿童窗口窗口正在售3张票
-------儿童窗口窗口正在售2张票
-------儿童窗口窗口正在售1张票
---中年窗口---窗口正在售20张票
---中年窗口---窗口正在售19张票
---中年窗口---窗口正在售18张票
---中年窗口---窗口正在售17张票
---中年窗口---窗口正在售16张票
---中年窗口---窗口正在售15张票
---中年窗口---窗口正在售14张票
---中年窗口---窗口正在售13张票
---中年窗口---窗口正在售12张票
---中年窗口---窗口正在售11张票
---中年窗口---窗口正在售10张票
---中年窗口---窗口正在售9张票
---中年窗口---窗口正在售8张票
---中年窗口---窗口正在售7张票
---中年窗口---窗口正在售6张票
---中年窗口---窗口正在售5张票
---中年窗口---窗口正在售4张票
---中年窗口---窗口正在售3张票
---中年窗口---窗口正在售2张票
---中年窗口---窗口正在售1张票
*/
//用第二中方式来创建线程:同样每个线程可以处理不同的资源
class Tc implements Runnable
{
private int tickets = 20;//每个线程各自卖20张票

public String name ;
public Tc(String name)
{
this.name = name;
}
public void run()
{
while(tickets > 0)
{
System.out.printf("%s窗口正在售%d张票\n",name,tickets);
tickets --;
}
}
}
public class zhang4
{
public static void main(String[] args)
{
Tc aa = new Tc("老人窗口----");
Thread t1 = new Thread(aa);
t1.run();//实现一个窗口卖票

Tc bb = new Tc("-------儿童窗口");
Thread t2 = new Thread(bb);
t2.run();//不同的类对象,其属性占用不同的内存空间,这是根本

Tc cc = new Tc("---中年窗口---");
Thread t3 = new Thread(cc);
t3.run();
}
}
/*
运行结果:和上面的程序相同
老人窗口----窗口正在售20张票
老人窗口----窗口正在售19张票
老人窗口----窗口正在售18张票
老人窗口----窗口正在售17张票
老人窗口----窗口正在售16张票
老人窗口----窗口正在售15张票
老人窗口----窗口正在售14张票
老人窗口----窗口正在售13张票
老人窗口----窗口正在售12张票
老人窗口----窗口正在售11张票
老人窗口----窗口正在售10张票
老人窗口----窗口正在售9张票
老人窗口----窗口正在售8张票
老人窗口----窗口正在售7张票
老人窗口----窗口正在售6张票
老人窗口----窗口正在售5张票
老人窗口----窗口正在售4张票
老人窗口----窗口正在售3张票
老人窗口----窗口正在售2张票
老人窗口----窗口正在售1张票
-------儿童窗口窗口正在售20张
-------儿童窗口窗口正在售19张
-------儿童窗口窗口正在售18张
-------儿童窗口窗口正在售17张
-------儿童窗口窗口正在售16张
-------儿童窗口窗口正在售15张
-------儿童窗口窗口正在售14张
-------儿童窗口窗口正在售13张
-------儿童窗口窗口正在售12张
-------儿童窗口窗口正在售11张
-------儿童窗口窗口正在售10张
-------儿童窗口窗口正在售9张票
-------儿童窗口窗口正在售8张票
-------儿童窗口窗口正在售7张票
-------儿童窗口窗口正在售6张票
-------儿童窗口窗口正在售5张票
-------儿童窗口窗口正在售4张票
-------儿童窗口窗口正在售3张票
-------儿童窗口窗口正在售2张票
-------儿童窗口窗口正在售1张票
---中年窗口---窗口正在售20张票
---中年窗口---窗口正在售19张票
---中年窗口---窗口正在售18张票
---中年窗口---窗口正在售17张票
---中年窗口---窗口正在售16张票
---中年窗口---窗口正在售15张票
---中年窗口---窗口正在售14张票
---中年窗口---窗口正在售13张票
---中年窗口---窗口正在售12张票
---中年窗口---窗口正在售11张票
---中年窗口---窗口正在售10张票
---中年窗口---窗口正在售9张票
---中年窗口---窗口正在售8张票
---中年窗口---窗口正在售7张票
---中年窗口---窗口正在售6张票
---中年窗口---窗口正在售5张票
---中年窗口---窗口正在售4张票
---中年窗口---窗口正在售3张票
---中年窗口---窗口正在售2张票
---中年窗口---窗口正在售1张票
*/
//用第二中方式创建线程:多个线程处理的是同一资源
class Tc implements Runnable
{
private int tickets = 10000;//3个线程一共处理100张票

public void run()
{
while(true)
{
synchronized("zhang")
{
if(tickets > 0)
{
System.out.printf("%s窗口正在售%d张票\n",Thread.currentThread().getName(),tickets);
tickets --;

}
else
break;
}
}
}
}
public class zhang5
{
public static void main(String[] args)
{
Tc aa = new Tc();
Thread t1 = new Thread(aa); //aa对象
t1.setName("老人窗口");
t1.start();//实现一个窗口卖票

Thread t2 = new Thread(aa); //aa对象
t2.setName("儿童窗口");
t2.start();//不同的类对象,其属性占用不同的内存空间,这是根本

Thread t3 = new Thread(aa); //aa对象
t3.setName("中年窗口");
t3.start();
}
}
/*
运行结果是:三个售票口共同处理1000张票
*/
/*综上:实现Runnable接口相对于扩展Thread类来说,具有无可比拟的优势。
这种方式不仅有利于程序的健壮性,使代码能够被多个线程共享,而且代码和数据资源相对独立,
从而特别适合多个具有相同代码的线程去处理同一资源的情况。
这样一来,线程、代码和数据资源三者有效分离,很好地体现了面向对象程序设计的思想。
因此,几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。*/

时间: 2024-10-16 04:57:52

Java中创建线程用第几种方式的相关文章

spring中创建bean对象的三种方式以及作用范围

时间:2020/02/02 一.在spring的xml配置文件中创建bean对象的三种方式: 1.使用默认构造函数创建.在spring的配置文件中使用bean标签,配以id和class属性之后,且没有其他属性和标签时采用的就是默认构造函数创建bean对象,此时如果类中没有默认构造函数函数,则对象无法创建. <bean id="one" class="sdnu.machi.one"></bean> 如果one.class中没有默认构造函数则会报

iOS中创建单例的两种方式

刚刚开始做iOS开发的时候,不知道怎么创建单例,在网上搜的也大多数都不太全,所以总结了一下创建单例的两种方式 首先在.h文件中声明类方法 1 +(instancetype)sharedUtils; 然后在.m文件中实现它,实现的方法有两种 第一种,在创建一个对象时先判断在程序中有没有创建过这个对象 1 static PublicUtils *DefaultManager = nil; 2 3 +(instancetype)sharedUtils 4 { 5 if (!DefaultManager

java中创建线程的三种方法以及区别

Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例.Java可以用三种方式来创建线程,如下所示: 1)继承Thread类创建线程 2)实现Runnable接口创建线程 3)使用Callable和Future创建线程 下面让我们分别来看看这三种创建线程的方法. ------------------------继承Thread类创建线程--------------------- 通过继承Thread类来创建并启动多线程的一般步骤如下 1]d定义Thread类的子类

java中创建线程的3种方法

1.继承Thread类优点:可以直接使用Thread类中的方法,代码比较简单.缺点:继承Thread类之后不能继承其他类. 2.实现Runable接口优点:实现接口,比影响继承其他类或实现接口.缺点: 3.实现Callable接口优点:可以获取返回值,可以抛出异常.缺点:实现方法相对复杂 三种方法的实现例 public static void main(String[] args) throws InterruptedException, ExecutionException { //继承Thr

Java中创建线程的两种方式

1.定义实现Runnable接口的线程类,步骤如下: (1)创建实现了Runnable接口的线程类Runner: (2)重写Runnable接口的run()方法,用于定义线程的运行体:(Runnable接口只有这一个方法) (3)实例化线程类Runner: (4)创建线程实例,并将线程类Runner的实例传递给它作为构造函数的参数: (5)启动线程: 代码如下所示: 1 public class TestThread { 2 public static void main(String args

JAVA中创建线程的方法及比较

JAVA中提供了Thread类来创建多线程的应用,常用的方式有以下2种. 一.实现Runnable接口来创建线程 1.创建一个任务类,实现Runnable接口,并重写run()方法,run()方法中的内容就是需要线程完成的任务. 2.创建一个任务类的对象. 3.任务类必须在线程中执行,因此将任务类的对象作为参数,创建一个Thread类对象,该Thread类对象才是真正的线程对象. 4.调用Thread线程类对象的start()方法,来启动一个线程. 代码实例: 1 public class Te

Java中 实现多线程成的三种方式(继承,实现,匿名内部类)

------------------------------------------------------------------------------------------------------------ /** 第一种方式:继承Thread类 *             1. 定义一个类,然后让该类继承Thread类 *             2. 重写run方法 *             3. 创建定义的这个类的对象 *             4. 启动线程 */ //继承

iOS中保证线程安全的几种方式与性能对比

来源:景铭巴巴 链接:http://www.jianshu.com/p/938d68ed832c 一.前言 前段时间看了几个开源项目,发现他们保持线程同步的方式各不相同,有@synchronized.NSLock.dispatch_semaphore.NSCondition.pthread_mutex.OSSpinLock.后来网上查了一下,发现他们的实现机制各不相同,性能也各不一样.不好意思,我们平常使用最多的@synchronized是性能最差的.下面我们先分别介绍每个加锁方式的使用,在使用

创建线程的第三种方式——使用Callable接口

Callable是类似于Runnable的接口,实现Callable的类和实现Runnable的类都是可被其他线程执行的任务. 优点:有返回值 缺点:实现繁琐 简单实现: CallableAndFuture.java /** * 简单实现 * * @author :liuqi * @date :2018-06-13 11:10. */ public class CallableAndFuture { static class MyThread implements Callable<String