java两个线程

1. java创建两个线程的方法和它们的区别

方法1、通过扩展Thread类来创建多线程

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

1 public class MutliThreadDemo {
2 public static void main(String[] args) {
3 MutliThread m1=new MutliThread("Window 1");
4 MutliThread m2=new MutliThread("Window 2");
5 MutliThread m3=new MutliThread("Window 3");
6 m1.start();
7 m2.start();
8 m3.start();
9 }
10 }

1 public class MutliThread extends Thread {
2 private int ticket=100;//每个线程都拥有100张票
3
4 public MutliThread (){}
5 public MutliThread (String name){
6 super(name);
7 }
8
9 @Override
10 public void run() {
11 while(ticket>0){
12 System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
13 }
14 }
15 }

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

从结果可以看到，每个线程分别对应100张电影票，之间并无任何关系，这就说明每个线程之间是平等的，没有优先级关系，因此都有机会得到CPU的处理。但是结果

显示这三个线程并不是依次交替执行，而是在三个线程同时被执行的情况下，有的线程被分配时间片的机会多，票被提前卖完，而有的线程被分配时间片的机会比较

少，票迟一些卖完。

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

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

1 public class MutliThreadDemo {
2 public static void main(String[] args) {
3 MutliThread m1=new MutliThread("Window 1");
4 MutliThread m2=new MutliThread("Window 2");
5 MutliThread m3=new MutliThread("Window 3");
6 Thread t1=new Thread(m1);
7 Thread t2=new Thread(m2);
8 Thread t3=new Thread(m3);
9 t1.start();
10 t2.start();
11 t3.start();
12 }
13 }

1 public class MutliThread implements Runnable{
2 private int ticket=100;//每个线程都拥有100张票
3 private String name;
4 MutliThread(String name){
5 this.name=name;
6 }
7 public void run(){
8 while(ticket>0){
9 System.out.println(ticket--+" is saled by "+name);
10 }
11 }
12 }

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

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

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

现实中也存在这样的情况，比如模拟一个火车站的售票系统，假如当日从A地发往B地的火车票只有100张，且允许所有窗口卖这100张票，那么每一个窗口也相当于一个线程，但是这时和前面的例子不同之处就在于所有线程处理的资源是同一个资源，即100张车票。如果还用前面的方式来创建线程显然是无法实现的，这种情况该怎样处理呢？看下面这个程序，程序代码如下所示：

1 public class MutliThreadDemo {
2 public static void main(String[] args) {
3 MutliThread m=new MutliThread();
4 Thread t1=new Thread(m);
5 Thread t2=new Thread(m);
6 Thread t3=new Thread(m);
7 t1.start();
8 t2.start();
9 t3.start();
10 }
11 }

1 public class MutliThread implements Runnable{
2 private int ticket=100;//每个线程都拥有100张票
3 public void run(){
4 while(ticket>0){
5 System.out.println(ticket--+" is saled by "+Thread.currentThread());
6 }
7 }
8 }

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

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

实现Runnable接口相对于扩展Thread类来说，具有无可比拟的优势。这种方式不仅有利于程序的健壮性，使代码能够被多个线程共享，而且代码和数据资源相对独立，从而特别适合多个具有相同代码的线程去处理同一资源的情况。这样一来，线程、代码和数据资源三者有效分离，很好地体现了面向对象程序设计的思想。因此，几乎所有的多线程程序都是通过实现Runnable接口的方式来完成的。

区别

第1只线程创建的办法有1个弊端:

线程和线程可以运行的任务概念有了1起，重用性有限制。

更多时候可以把线程和线程可以运行的任务分解开

求教高手:第1只办法如何解释是线程和任务概念有了1起，如何解释了重用性有限制

第2只办法如何查看出的无概念有1起 ，重用性没有限制?

办理解不了，着急上火，感谢感谢感谢感谢帮帮忙。

public class Th读取Demo {

public st安奈特c void main(String[] args) {

Th读取 p1 = new Person1();

Th读取 p2 = new Person2();

p1.start();

p2.start();

}

}

//左右是第1只创建线程的办法

class Person1 extends Th读取{

public void run(){

for(int i=0;i<1000;i++){

System.out.println("我是线程1");

}

}

}

class Person2 extends Th读取{

public void run(){

for(int i=0;i<1000;i++){

System.out.println("我是线程2");

}

}

}

---------------------------------------------------------------------------------------------------------------------------------

public class Th读取Demo2 {

public st安奈特c void main(String[] args) {

Runnable runnable1 = new Person3();

Runnable runnable2 = new Person4();

Th读取 t1 = new Th读取(runnable1);

Th读取 t2 = new Th读取(runnable2);

t1.start();

t2.start();

}

}

//左右是第2只创建线程的办法

class Person3 implements Runnable{

public void run() {

for(int i=0;i<1000;i++){

System.out.println("我是线程3?");

}

}

}

class Person4implements Runnable{

public void run() {

for(int i =0;i<1000;i++){

System.out.println("我是线程4");

}

}

}

2. java 中 如何让一个方法内最多只能有两个线程访问

信号量Semaphore。下面代码里，一个semp的信号量初始值为5，.acquire()一次-1，.release()一次+1，如果信号量值为0的时候.acquire()就会阻塞线程，直到别的线程.release()。下面的实例是允许最多5个线程同时访问.acquire()和.release()之间的代码，你设置初始值为2就可以了。

publicclassSemaphoreTest{

publicstaticvoidmain(String[]args){
//线程池
ExecutorServiceexec=Executors.newCachedThreadPool();
//只能5个线程同时访问
finalSemaphoresemp=newSemaphore(5);
//模拟20个客户端访问
for(intindex=0;index<20;index++){
finalintNO=index;
Runnablerun=newRunnable(){
publicvoidrun(){
try{
//获取许可
semp.acquire();
System.out.println("Accessing:"+NO);
Thread.sleep((long)(Math.random()*10000));
//访问完后，释放，如果屏蔽下面的语句，则在控制台只能打印5条记录，之后线程一直阻塞
semp.release();
}catch(InterruptedExceptione){
}
}
};
exec.execute(run);
}
//退出线程池
exec.shutdown();
}
}

给你个链接看看

http://blog.csdn.net/shihuacai/article/details/8856526

3. java两个线程之间如何实现切换

仔细看看30 60关键点，跟sleep时间长短有关，短了可能来不及执行又换另一线程
public class Test extends Thread {
public static void main(String[] args){
new Test().start();
new Test().start();
new Test().start();
}
public void run(){
try{
for(int i=0;i<100;i++){
System.out.println(getName()+":"+i);
if(i==30){
sleep(100);
}
if(i==60){
sleep(100);
}
}
}catch(Exception e){}

}
}

4. java开两个线程操作同一个对象会有什么情况

如果这个对象被上线程锁（线程安全），那么只有一个能获取到执行，另一个必须等待
如果只是部分代码被上锁，他们可以共享公共资源，上锁部分就必须等待
如果没有任何限制，那么每个线程都可能创建一个新对象，互不干扰

举个例子，
有台打印机，打印程序，如果a.b都想打印，那么它们必须等待先来的完成，打印程序只能有一个，线程上锁了
有一段服务器代码，有两个甚至多个网页去请求他，他会给每一个线程创建一个一样的对象去处理事物，而不用等待别人操作完

你说的两个线程去操作一个对象，那应该是操作共享资源，只要没有内存溢出等等异常是完全可以正常执行的

5. 在java中，多线程真的是多个线程同时运行吗

多CPU当然是真多线程。就是CPU可能同时在执行4个线程。
但是不是多核也没关系。因为线程的执行往往会挂起，等待IO之类。这时候CPU会转到别的线程来执行。这是分时系统的一大特征。当然人是感觉不到的。
用多线程，比如你的处理分为两大部分，一部分产生数据，一部分显示数据，产生数据比较耗时。（生产者消费者模型）。这个时候用多线程，一个来产生数据，一个来显示数据。对于界面来说就不会在处理产生数据的时候产生假死的现象。
希望能帮到你。

6. java多线程如何创建多个多线程

Java 多线程的同步依靠的是对象锁机制，这个问题需要我们不断的学习相关的问题。下面我们就来详细的学习下如何才能更好的进行具体内容的使用。synchronized关键字的背后就是利用了封锁来实现对共享资源的互斥访问。
下面以一个简单的实例来进行对比分析。实例要完成的工作非常简单，就是创建10个线程，每个线程都打印从0到99这100个数字，我们希望线程之间不会出现交叉乱序打印，而是顺序地打印。
先来看第一段代码，这里我们在run()方法中加入了synchronized关键字，希望能对run方法进行互斥访问，但结果并不如我们希望那样，这是因为这里synchronized锁住的是this对象，即当前运行线程对象本身。 Java 多线程代码中创建了10个线程，而每个线程都持有this对象的对象锁，这不能实现线程的同步。
Java多线程代码如下
1.package com.vista;
2.class MyThread implements java.lang.Runnable
3.{
4.private int threadId;
5.public MyThread(int id)
6.{
7.this.threadId = id;
8.}
9.@Override
10.public synchronized void run()
11.{
12.for (int i = 0; i < 100; ++i)
13.{
14.System.out.println("Thread ID: " + this.threadId + " : " + i);
15.}
16.}
17.}
18.public class ThreadDemo
19.{
20./**
21.* @param args
22.* @throws InterruptedException
23.*/
24.public static void main(String[] args) throws InterruptedException
25.{
26.for (int i = 0; i < 10; ++i)
27.{
28.new Thread(new MyThread(i)).start();
29.Thread.sleep(1);
30.}
31.}
32.}
以上就是对Java多线程的详细代码介绍。

7. java的这两个线程先执行谁

首先，你这里不是“两个”线程。。
你这里的是先执行
t.start();然后再迅速地跳到tt.ms();
所以，你可以说是t.start()与tt.m2()是同时执行的。
但是，由于分配线程所需要的空间需要一段时间，一般情况下是会是它的下一个语句先执行，即tt.m2()先执行。等到空间分配好之后，就是线程t的执行了

8. java中怎么实现两个线程的信息传递

java两个线程之间可以通过使用全局变量，然后使用set和get方法就可以传递变量，实例如下：

publicstaticStringpub="";
publicstaticvoidmain(String[]args){
finalThreadt2=newThread(){
@Override
publicvoidrun(){
//打印线程1传递过来的值
System.out.println(pub);
}
};
Threadt1=newThread(){
@Override
publicvoidrun(){
Stringthread1="thread1";
//将值thread1传递给线程2
pub=thread1;
t2.start();
}
};
t1.start();
}

9. java 程序开了两个线程为什么只有一个线程执行

1 你的变量i对于两个线程来说是全局变量，有一个线程执行完成后，i都惠变成0，while不可能再执行；
2 你的线程方法定义成了同步，也就是说只有一个线程的while执行完成后，才会执行下一个线程的逻辑；

10. JAVA多线程，怎么总是输出两个同样的

这应该是java中多线程的安全问题吧，CPU处理切换时间片的速率是非常快的，
当线程1判断完之后还没来得及输出，时间片就切换到线程2上了，
然后又进行了一次判断结果还是大于0，但是还没等到线程2输出就又回到了线程1，接着执行
输出语句，比如输出10，输出完之后又一次回到线程2上进行第二次输出，输出的结果和线程1
一样（10）。我觉得应该是临时阻塞问题。 希望能够采纳.