java如何实现线程

Ⅰ java中如何实现多线程

1.实现Runnable接口
2.继承Thread类

覆盖里面的 run方法 即可。~

Ⅱ java中如何启动一个新的线程

java开启新线程的三种方法：

方法1：继承类

1）：定义一个继承自Java.lang.Thread类的类A.

2）：覆盖A类Thread类中的run方法。

3）：我们编写需要在run方法中执行的操作：run方法中的代码，线程执行体。

4）：在main方法（线程）中，创建一个线程对象并启动线程。

(1)创建线程类对象:

A类 a = new A类();

(2)调用线程对象的start方法:

a.start();//启动一个线程

注意：不要调用run方法。如果run方法被称为对象调用方法，则仍然只有一个线程，并且没有启动新线程。

创建启动线程实例：

(2)java如何实现线程扩展阅读：

启动新线程的两种方式对比

继承方式:

1):从设计上分析，Java中类是单继承的,如果继承了Thread了,该类就不能再有其他的直接父类了.

2):从操作上分析,继承方式更简单,获取线程名字也简单.(操作上,更简单)

3):从多线程共享同一个资源上分析,继承方式不能做到.

实现方式:

1):从设计上分析，Java中类可以多实现接口,此时该类还可以继承其他类,并且还可以实现其他接口，设计更为合理.

2):从操作上分析,实现方式稍微复杂点,获取线程名字也比较复杂,得使用Thread.currentThread()来获取当前线程的引用.

3):从多线程共享同一个资源上分析,实现方式可以做到(是否共享同一个资源).

补充：实现方式获取线程名字：

String name = Thread.currentThread().getName();

Ⅲ java中如何实现线程的加入

{
	publicMyJoinThread()
	{
		();
	}
	publicMyJoinThread(Stringname)
	{
		super(name);
	}
	publicvoidrun()
	{
		for(inti=0;i<10;i++)
		{
			System.out.println(super.getName()+":"+i);
		}
	}
}
publicclassJoinTest
{
	publicstaticvoidmain(String[]args)
	{
		MyJoinThreadthread=newMyJoinThread("第1个线程");
		thread.start();
		for(inti=0;i<10;i++)
		{
			System.out.println(Thread.currentThread().getName()+":"+i);
			if(i==5)
			{
				try
				{
					thread.join();
				}
				catch(InterruptedExceptione)
				{
					System.out.println("线程被中断");
				}
			}
		}
	}
}

Ⅳ java怎么创建一个线程

Java线程类也是一个类,它的实例都继承自java.lang.Thread或其子类。可以用如下方式用java中创建一个线程：

Treadthread=newThread();

执行该线程可以调用该线程的start()方法:

thread.start();

编写线程运行时执行的代码有两种方式：一种是创建Thread子类的一个实例并重写run方法，第二种是创建类的时候实现Runnable接口。接下来我们会具体讲解这两种方法：

创建Thread的子类

创建Thread子类的一个实例并重写run方法，run方法会在调用start()方法之后被执行。例子如下：

{
publicvoidrun(){
System.out.println("MyThreadrunning");
}
}

可以用如下方式创建并运行上述Thread子类

MyThreadmyThread=newMyThread();
myTread.start();

一旦线程启动后start方法就会立即返回，而不会等待到run方法执行完毕才返回。就好像run方法是在另外一个cpu上执行一样。当run方法执行后，将会打印出字符串MyThread running。

实现Runnable接口

第二种编写线程执行代码的方式是新建一个实现了java.lang.Runnable接口的类的实例，实例中的方法可以被线程调用。下面给出例子：

{
publicvoidrun(){
System.out.println("MyRunnablerunning");
}
}

为了使线程能够执行run()方法，需要在Thread类的构造函数中传入MyRunnable的实例对象。示例如下：

Threadthread=newThread(newMyRunnable());
thread.start();

当线程运行时，它将会调用实现了Runnable接口的run方法。上例中将会打印出”MyRunnable running”。

Ⅳ 如何在java中实现线程

1 继承Thread类 ，使用new Thread(）.start();
public class ThreadTest extends Thread {
private static int count = 0;
public void run() {
{
System.out.println("ThreadTest" + count);
Random ran = new Random();
int time = ran.nextInt(1000);
System.out.println("休眠时间=" + time);
TimeUnit.MILLISECONDS.sleep(time);
count++;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

2实现Runnable接口 使用依托于Tread 类:new Thread(new Runnable()）.start();
public class RunnableTest implements Runnable{

private static int count = 0;
public RunnableTest (){
}

public void run() {
System.out.println("RunnableTest" + count);
// 线程调度器，可以切换线程
Thread.yield();
count++;
}

}

Ⅵ java中怎样实现多线程

//简单的演示,四个人吃包子,各吃各的!
publicclassThreadTest{
	publicstaticvoidmain(String[]args){
		String[]arr={"张回333","李----四","-----王五答","赵六666"};
		for(inti=0;i<4;i++){
			newThread(newRunnable(){
				inta=1;
				publicvoidrun(){
					while(a<100)
					System.out.println(Thread.currentThread().getName()+"在吃包子,吃了"+(a++)+"个了");
				}
			},arr[i]){
			}.start();
		}
	}
}

Ⅶ 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线程间

线程间的通信方式
同步
这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信。
参考示例：
public class MyObject {
synchronized public void methodA() {
//do something....
}
synchronized public void methodB() {
//do some other thing
}
}
public class ThreadA extends Thread {
private MyObject object;
//省略构造方法
@Override
public void run() {
super.run();
object.methodA();
}
}
public class ThreadB extends Thread {
private MyObject object;
//省略构造方法
@Override
public void run() {
super.run();
object.methodB();
}
}
public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
//线程A与线程B 持有的是同一个对象:object
ThreadA a = new ThreadA(object);
ThreadB b = new ThreadB(object);
a.start();
b.start();
}
}
由于线程A和线程B持有同一个MyObject类的对象object，尽管这两个线程需要调用不同的方法，但是它们是同步执行的，比如：线程B需要等待线程A执行完了methodA()方法之后，它才能执行methodB()方法。这样，线程A和线程B就实现了 通信。
这种方式，本质上就是“共享内存”式的通信。多个线程需要访问同一个共享变量，谁拿到了锁（获得了访问权限），谁就可以执行。