简单Java多线程代码求解

因为你new了两次

成都创新互联-专业网站定制、快速模板网站建设、高性价比金安网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式金安网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖金安地区。费用合理售后完善，10年实体公司更值得信赖。

试着在Task类内创建一个对象 然后锁住这个对象

多线程的java 程序如何编写？

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

新建状态:

使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

就绪状态:

当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

运行状态:

如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。

阻塞状态:

如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

死亡状态:

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

java求代码,创建三个线程,设置线程名,要求每个线程执行2次

原则上一个线程只能执行一次，只有创建2个同样的线程分别执行一次，达到你这个目的：

public class Test {

public static void main(String[] args) throws InterruptedException {

exeThread(new myThread("线程1"));

exeThread(new myThread("线程1"));

exeThread(new myThread("线程2"));

exeThread(new myThread("线程2"));

exeThread(new myThread("线程3"));

exeThread(new myThread("线程3"));

}

public static void exeThread(Thread t) {

t.start();

}

}

class myThread extends Thread {

public myThread(String name) {

super(name);

}

@Override

public void run() {

System.out.println("线程" + this.getName() + "执行了");

}

}

Java语言：Java多线程怎样创建

Java提供了线程类Thread来创建多线程的程序。其实，创建线程与创建普通的类的对象的操作是一样的，而线程就是Thread类或其子类的实例对象。每个Thread对象描述了一个单独的线程。要产生一个线程，有两种方法：

需要从Java.lang.Thread类派生一个新的线程类，重载它的run()方法；

实现Runnalbe接口，重载Runnalbe接口中的run()方法。

但，为什么Java要提供两种方法来创建线程呢？它们都有哪些区别？相比而言，哪一种方法更好呢？

在Java中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类.这样，如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的，那么这个自定义类就不能再去扩展其他的类，也就无法实现更加复杂的功能。因此，如果自定义类必

须扩展其他的类，那么就可以使用实现Runnable接口的方法来定义该类为线程类，这样就可以避免Java单继承所带来的局限性。

还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享.

（1）通过扩展Thread类来创建多线程

假设一个影院有三个售票口，分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票，分别是儿童票、成人票和老人票。三个窗口需要同时卖票，而现在只有一个售票员，这个售票员就相当于一个CPU，三个窗口就相当于三个线程。通过程序来看一看是如

何创建这三个线程的。

public class MutliThreadDemo {

public static void main(String [] args){

MutliThread m1=new MutliThread("Window 1");

MutliThread m2=new MutliThread("Window 2");

MutliThread m3=new MutliThread("Window 3");

m1.start();

m2.start();

m3.start();

}

}

class MutliThread extends Thread{

private int ticket=100;//每个线程都拥有100张票

MutliThread(String name){

super(name);//调用父类带参数的构造方法

}

public void run(){

while(ticket0){

System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());

}

}

}

程序中定义一个线程类，它扩展了Thread类。利用扩展的线程类在MutliThreadDemo类的主方法中创建了三个线程对象，并通过start()方法分别将它们启动。

从结果可以看到，每个线程分别对应100张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。但是结果显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机

会多，票被提前卖完，而有的线程被分配时间片的机会比较少，票迟一些卖完。

可见，利用扩展Thread类创建的多个线程，虽然执行的是相同的代码，但彼此相互独立，且各自拥有自己的资源，互不干扰。

（2）通过实现Runnable接口来创建多线程

public class MutliThreadDemo2 {

public static void main(String [] args){

MutliThread m1=new MutliThread("Window 1");

MutliThread m2=new MutliThread("Window 2");

MutliThread m3=new MutliThread("Window 3");

Thread t1=new Thread(m1);

Thread t2=new Thread(m2);

Thread t3=new Thread(m3);

t1.start();

t2.start();

t3.start();

}

}

class MutliThread implements Runnable{

private int ticket=100;//每个线程都拥有100张票

private String name;

MutliThread(String name){

this.name=name;

}

public void run(){

while(ticket0){

System.out.println(ticket--+" is saled by "+name);

}

}

}

由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和（1）结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。

可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。

由于这三个线程也是彼此独立，各自拥有自己的资源，即100张电影票，因此程序输出的结果和例4.2.1的结果大同小异。均是各自线程对自己的100张票进行单独的处理，互不影响。

可见，只要现实的情况要求保证新建线程彼此相互独立，各自拥有资源，且互不干扰，采用哪个方式来创建多线程都是可以的。因为这两种方式创建的多线程程序能够实现相同的功能。

（3）通过实现Runnable接口来实现线程间的资源共享

现实中也存在这样的情况，比如模拟一个火车站的售票系统，假如当日从A地发往B地的火车票只有100张，且允许所有窗口卖这100张票，那么每一个窗口也相当于一个线程，但是这时和前面的例子不同之处就在于所有线程处理的资源是同一个资源，即100张车票。如果

还用前面的方式来创建线程显然是无法实现的，这种情况该怎样处理呢？看下面这个程序，程序代码如下所示：

public class MutliThreadDemo3 {

public static void main(String [] args){

MutliThread m=new MutliThread();

Thread t1=new Thread(m,"Window 1");

Thread t2=new Thread(m,"Window 2");

Thread t3=new Thread(m,"Window 3");

t1.start();

t2.start();

t3.start();

}

}

class MutliThread implements Runnable{

private int ticket=100;//每个线程都拥有100张票

public void run(){

while(ticket0){

System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());

}

}

}

结果正如前面分析的那样，程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。

可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的，读者想想看，为什么？

实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者

有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。

网站名称：java创建多线程的代码,java代码实现多线程
分享网址：http://azwzsj.com/article/hohjdc.html