java如何几个线程做一个方法

① java多线程有几种实现方法

• 继承Thread类来实现多线程:

当我们自定义的类继承Thread类后，该类就为一个线程类,该类为一个独立的执行单元，线程代码必须编写在run()方法中,run方法是由Thread类定义，我们自己写的线程类必须重写run方法。

run方法中定义的代码为线程代码，但run方法不能直接调用，如果直接调用并没有开启新的线程而是将run方法交给调用的线程执行

要开启新的线程需要调用Thread类的start()方法，该方法自动开启一个新的线程并自动执行run方法中的内容




*java多线程的启动顺序不一定是线程执行的顺序，各个线程之间是抢占CPU资源执行的，所有有可能出现与启动顺序不一致的情况。




CPU的调用策略：

如何使用CPU资源是由操作系统来决定的，但操作系统只能决定CPU的使用策略不能控制实际获得CPU执行权的程序。




线程执行有两种方式：




1.抢占式：

目前PC机中使用最多的一种方式，线程抢占CPU的执行权，当一个线程抢到CPU的资源后并不是一直执行到此线程执行结束，而是执行一个时间片后让出CPU资源，此时同其他线程再次抢占CPU资源获得执行权。




2.轮循式;

每个线程执行固定的时间片后让出CPU资源，以此循环执行每个线程执行相同的时间片后让出CPU资源交给下一个线程执行。

② java两个线程同时调用一个类里的同一个方法，这样会出现什么情况有没有问题

根据不同的情况可能存在的情况有：

③ java中有几种方法可以实现一个线程

java5以前，有如下两种：
有两种实现方法，分别使用new Thread()和new Thread(runnable)形式，第一种直接调用thread的run方法，所以，我们往往使用Thread子类，即new SubThread()。第二种调用runnable的run方法。
第一种：
new Thread(){}.start();这表示调用Thread子类对象的run方法，new Thread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：
new Thread(){
public void run(){
}
}.start();

第二种：
new Thread(new Runnable(){}).start();这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下：
new Thread(new Runnable(){
public void run(){
}
}
).start();
从java5开始，还有如下一些线程池创建多线程的方式：
ExecutorService pool = Executors.newFixedThreadPool(3)
for(int i=0;i<10;i++)
{
pool.execute(new Runable(){public void run(){}});
}
Executors.newCachedThreadPool().execute(new Runable(){public void run(){}});
Executors.newSingleThreadExecutor().execute(new Runable(){public void run(){}});

④ JAVA多线程有哪几种实现方式

JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。

1、继承Thread类实现多线程
继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

[java]view plain

• {

• publicvoidrun(){

• System.out.println("MyThread.run()");

• }

• }

• 在合适的地方启动线程如下：



[java]view plain

• MyThreadmyThread1=newMyThread();

• MyThreadmyThread2=newMyThread();

• myThread1.start();

• myThread2.start();



• 2、实现Runnable接口方式实现多线程


• 如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：



[java]view plain

• {

• publicvoidrun(){

• System.out.println("MyThread.run()");

• }

• }

• 为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：



[java]view plain

• MyThreadmyThread=newMyThread();

• Threadthread=newThread(myThread);

• thread.start();

• 事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：



[java]view plain

• publicvoidrun(){

• if(target!=null){

• target.run();

• }

• }



• 3、使用ExecutorService、Callable、Future实现有返回结果的多线程


• ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问http://www.javaeye.com/topic/366591 ，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。


• 可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。

⑤ 在Java 中多线程的实现方法有哪些，如何使用

1、 认识Thread和Runnable

Java中实现多线程有两种途径：继承Thread类或者实现Runnable接口。Runnable是接口，建议用接口的方式生成线程，因为接口可以实现多继承，况且Runnable只有一个run方法，很适合继承。在使用Thread的时候只需继承Thread，并且new一个实例出来，调用start()方法即可以启动一个线程。

Thread Test = new Thread();

Test.start();

在使用Runnable的时候需要先new一个实现Runnable的实例，之后启动Thread即可。

Test impelements Runnable;

Test t = new Test();

Thread test = new Thread(t);

test.start();

总结：Thread和Runnable是实现java多线程的2种方式，runable是接口，thread是类，建议使用runable实现java多线程，不管如何，最终都需要通过thread.start()来使线程处于可运行状态。

2、 认识Thread的start和run

1） start：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到spu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2） run：

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。

3、 线程状态说明

线程状态从大的方面来说，可归结为：初始状态、可运行状态、不可运行状态和消亡状态，具体可细分为上图所示7个状态，说明如下：

1） 线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了thread实例后，线程就进入了初始状态；

2） 当该对象调用了start()方法，就进入可运行状态；

3） 进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态；

4） 进入运行状态后case就比较多，大致有如下情形：

·run()方法或main()方法结束后，线程就进入终止状态；

·当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态既停止当前线程，但并不释放所占有的资源)。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片；

·当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被锁牢(synchroniza,lock)，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片；

·当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。

·当线程调用stop方法，即可使线程进入消亡状态，但是由于stop方法是不安全的，不鼓励使用，大家可以通过run方法里的条件变通实现线程的stop。

⑥ 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

⑦ java中实现多线程的方法有几种以及如何实现多线程

java中实现多线程的方法有两种，1：继承Tread类；2：实现Runable接口

1、
{
//重写run()方法
publicvoidrun(){
//多线程要做的事
}
publicstaticvoidmain(Stringargs[]){
MyThreadm1=newMyThread();
MyThreadm2=newMyThread();
m1.start();
m2.start();
}
}

2、
{
//实现run()方法
publicvoidrun(){
//多线程要做的事
}
publicstaticvoidmain(Stringargs[]){
NThreadnt=newNThread();
newThread(nt,"nt1_name").start();
newThread(nt,"nt2_name").start();
}
}