java多线程实例代码

⑴ 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就实现了 通信。
这种方式，本质上就是“共享内存”式的通信。多个线程需要访问同一个共享变量，谁拿到了锁（获得了访问权限），谁就可以执行。

⑵ 如何使用Java编写多线程程序(1)

一、简介1、什么是线程要说线程，就必须先说说进程，进程就是程序的运行时的一个实例。线程呢可以看作单独地占有CPU时间来执行相应的代码的。对早期的计算机（如DOS）而言，线程既是进程，进程既是进程，因为她是单线程的。当然一个程序可以是多线程的，多线程的各个线程看上去像是并行地独自完成各自的工作，就像一台一台计算机上运行着多个处理机一样。在多处理机计算机上实现多线程时，它们确实可以并行工作，而且采用适当的分时策略可以大大提高程序运行的效率。但是二者还是有较大的不同的，线程是共享地址空间的，也就是说多线程可以同时读取相同的地址空间，并且利用这个空间进行交换数据。 2、为什么要使用线程为什么要使用多线程呢？学过《计算机体系结构》的人都知道。将顺序执行程序和采用多线程并行执行程序相比，效率是可以大大地提高的。比如，有五个线程thread1, thread2, thread3, thread4, thread5，所耗的CPU时间分别为4，5，1，2，7。（假设CPU轮换周期为4个CPU时间，而且线程之间是彼此独立的）顺序执行需要花费1Array个CPU时间，而并行需要的时间肯定少于1Array个CPU时间，至于具体多少时间要看那些线程是可以同时执行的。这是在非常小规模的情况下，要是面对大规模的进程之间的交互的话，效率可以表现得更高。 3、java中是如何实现多线程的与其他语言不一样的是，线程的观念在java是语言中是重要的，根深蒂固的，因为在java语言中的线程系统是java语言自建的， java中有专门的支持多线程的API库，所以你可以以最快的速度写一个支持线程的程序。在使用java创建线程的时候，你可以生成一个Thread类或者他的子类对象，并给这个对象发送start()消息（程序可以向任何一个派生自 Runnable 接口的类对象发送 start() 消息的），这样一来程序会一直执行，直到run返回为止，此时该线程就死掉了。在java语言中，线程有如下特点：§ 在一个程序中而言，主线程的执行位置就是main。而其他线程执行的位置，程序员是可以自定义的。值得注意的是对Applet也是一样。 § 每个线程执行其代码的方式都是一次顺序执行的。 § 一个线程执行其代码是与其他线程独立开来的。如果诸线程之间又相互协作的话，就必须采用一定的交互机制。 § 前面已经说过，线程是共享地址空间的，如果控制不当，这里很有可能出现死锁。 各线程之间是相互独立的，那么本地变量对一个线程而言就是完全独立，私有的。所以呢，线程执行时，每个线程都有各自的本地变量拷贝。对象变量(instance variable)在线程之间是可以共享的，这也就是为什么在java中共享数据对象是如此的好用，但是java线程不能够武断地访问对象变量：他们是需要访问数据对象的权限的。二、准备知识 在分析这个例子之前，然我们先看看关于线程的几个概念，上锁，信号量，和java所提供的API。 上锁对于大多数的程序而言，他们都需要线程之间相互的通讯来完成整个线程的生命周期，二实现线程之间同步的最简单的办法就是上锁。为了防止相互关联的两个线程之间错误地访问共享资源，线程需要在访问资源的时候上锁和解锁，对于锁而言，有读锁，写锁和读写锁等不同的同步策略。在java中，所有的对象都有锁；线程只需要使用synchronized关键字就可以获得锁。在任一时刻对于给定的类的实例，方法或同步的代码块只能被一个线程执行。这是因为代码在执行之前要求获得对象的锁。 信号量通常情况下，多个线程所访问为数不多的资源，那怎么控制呢？一个比较非常经典而起非常简单的办法就是采用信号量机制。信号量机制的含义就是定义一个信号量，也就是说能够提供的连接数；当有一个线程占用了一个连接时，信号量就减一；当一个线程是放了连接时，信号量就加一。

⑶ 如何在Java 中实现多线程

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

public class MyThread extends Thread {
public void run() {
System.out.println("MyThread.run()");
}
}

MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();

⑷ 求一个JAVA多线程例子，最好有代码，谢谢啦！

package a.b.test;
import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Calculate1000 implements Callable<Integer>{
public Calculate1000(){}

public Calculate1000(int a, int b){
this.a = a;
this.b = b;

}

int a;
int b;

/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
//同步
Calculate1000 ca1 = new Calculate1000();
Date ds1 = new Date();
int result = 0;
for(int i = 1 ; i <= 1000 ; i++){
result = ca1.add(i, result);
}
System.out.println(result);
System.out.println("同步用时" + (new Date().getTime() - ds1.getTime()) + "MS");

//异步
Date ds2 = new Date();
result = 0;
ExecutorService es = Executors.newFixedThreadPool(2);
Future<Integer> future1 = es.submit(new Calculate1000(1,500));
Future<Integer> future2 = es.submit(new Calculate1000(501,1000));
result = future1.get() + future2.get();
System.out.println(result);
System.out.println("异步用时" + (new Date().getTime() - ds2.getTime()) + "MS");
es.shutdown();
}
private int add(int a, int b) throws Exception{
Thread.sleep(10);
return a + b;
}
@Override
public Integer call() throws Exception {
int res = 0;
for(int i = a ; i <= b ; i++){
res = this.add(res, i);
}
return res;
}
}
楼主你试一下这段代码行不行，行的话请采纳！

⑸ java 多线程的例子

多线程实际上就是多个线程同时运行，至于那个先完成是不能确定的。

* @author Rollen-Holt 实现Runnable接口

* */

class hello implements Runnable {

public hello() {

}

public hello(String name) {

this.name = name;

}

public void run() {

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

System.out.println(name + "运行 " + i);

}

}

public static void main(String[] args) {

hello h1=new hello("线程A");

Thread demo= new Thread(h1);

hello h2=new hello("线程B");

Thread demo1=new Thread(h2);

demo.start();

demo1.start();

}

private String name;

}

可能运行结果：

⑹ 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多线程编程代码如下，输出结果如下:

首先，你同步的是具体的某个Test实例， 对于那个实例来说，实际上只有一个线程访问了那个代码块，但是sum和other却是多个线程同时去进行访问，实际上这是不安全的，如果你想实现每次都输出10000的效果，那么正确的应该是在Test.class上加锁，而不是获取Test实例的锁，修改后的代码如下：

publicclassTestextendsThread{

publicstaticintsum=10000;

publicstaticintother=0;

publicvoidgetMoney(){
synchronized(Test.class){

System.out.println(Thread.currentThread().getName()+"开始执行");
sum=sum-100;

System.out.println("sum-100");

other=other+100;

System.out.println("other+100");

System.out.println(sum+other);
System.out.println(Thread.currentThread().getName()+"执行完成");
}

}

publicvoidrun(){

getMoney();

}

publicstaticvoidmain(String[]agrs){

Threadt[]=newThread[10];

for(inti=0;i<=9;i++){

t[i]=newTest();

t[i].start();

}

}

}

// 上面代码能得到你的结果

⑻ 如何用Java编写多线程

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。
对于直接继承Thread的类来说，代码大致框架是：
?
123456789101112 class 类名 extends Thread{ 方法1; 方法2； … public void run(){ // other code… } 属性1； 属性2； … }
先看一个简单的例子：
?
/** * @author Rollen-Holt 继承Thread类,直接调用run方法 * */class hello extends Thread { public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i < 5; i++) { System.out.println(name + "运行 " + i); } } public static void main(String[] args) { hello h1=new hello("A"); hello h2=new hello("B"); h1.run(); h2.run(); } private String name; }
【运行结果】：
A运行 0
A运行 1
A运行 2
A运行 3
A运行 4
B运行 0
B运行 1
B运行 2
B运行 3
B运行 4
我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start（）方法。
当我们把上面的主函数修改为如下所示的时候：
?
123456 public static void main(String[] args) { hello h1=new hello("A"); hello h2=new hello("B"); h1.start(); h2.start(); }
然后运行程序，输出的可能的结果如下：
A运行 0
B运行 0
B运行 1
B运行 2
B运行 3
B运行 4
A运行 1
A运行 2
A运行 3
A运行 4
因为需要用到CPU的资源，所以每次的运行结果基本是都不一样的，呵呵。
注意：虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。
那么：为什么我们不能直接调用run（）方法呢？
我的理解是：线程的运行需要本地操作系统的支持。
如果你查看start的源代码的时候，会发现：
?
1234567891011121314151617 public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * group threads created/set up by the VM. Any new functionality added * to this method in the future may have to also be added to the VM. * * A zero status value corresponds to state "NEW". */ if (threadStatus != 0 || this != me) throw new IllegalThreadStateException(); group.add(this); start0(); if (stopBeforeStart) { stop0(throwableFromStop); } } private native void start0();
注意我用红色加粗的那一条语句，说明此处调用的是start0（）。并且这个这个方法用了native关键字，次关键字表示调用本地操作系统的函数。因为多线程的实现需要本地操作系统的支持。
但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。
通过实现Runnable接口：

大致框架是：
?
123456789101112 class 类名 implements Runnable{ 方法1; 方法2； … public void run(){ // other code… } 属性1； 属性2； … }

来先看一个小例子吧：
?
2930 /** * @author Rollen-Holt 实现Runnable接口 * */class hello implements Runnable { public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i < 5; i++) { System.out.println(name + "运行 " + i); } } public static void main(String[] args) { hello h1=new hello("线程A"); Thread demo= new Thread(h1); hello h2=new hello("线程B"); Thread demo1=new Thread(h2); demo.start(); demo1.start(); } private String name; }
【可能的运行结果】：
线程A运行 0
线程B运行 0
线程B运行 1
线程B运行 2
线程B运行 3
线程B运行 4
线程A运行 1
线程A运行 2
线程A运行 3
线程A运行 4

关于选择继承Thread还是实现Runnable接口？
其实Thread也是实现Runnable接口的：
?
12345678 class Thread implements Runnable { //… public void run() { if (target != null) { target.run(); } } }
其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有，Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。关于代理模式，我曾经写过一个小例子呵呵，大家有兴趣的话可以看一下：http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144847.html
Thread和Runnable的区别：
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
?
/** * @author Rollen-Holt 继承Thread类，不能资源共享 * */class hello extends Thread { public void run() { for (int i = 0; i < 7; i++) { if (count > 0) { System.out.println("count= " + count--); } } } public static void main(String[] args) { hello h1 = new hello(); hello h2 = new hello(); hello h3 = new hello(); h1.start(); h2.start(); h3.start(); } private int count = 5; }

【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
大家可以想象，如果这个是一个买票系统的话，如果count表示的是车票的数量的话，说明并没有实现资源的共享。
我们换为Runnable接口：
?
12345678910111213141516171819 /** * @author Rollen-Holt 继承Thread类，不能资源共享 * */class hello implements Runnable { public void run() { for (int i = 0; i < 7; i++) { if (count > 0) { System.out.println("count= " + count--); } } } public static void main(String[] args) { hello he=new hello(); new Thread(he).start(); } private int count = 5; }

【运行结果】：
count= 5
count= 4
count= 3
count= 2
count= 1

总结一下吧：
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

所以，本人建议大家劲量实现接口。
?