【线程定义】
定义：线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程(kernel thread)，而把用户线程(user thread)称为线程。
【实现方法】
1. 第一种继承：Thread类
class 类名extends Thread{
方法1；
方法2；
……
public void run(){
实现代码
}
}
2. 第二种：实现Runnable接口
class 类名 implements Runnable{
方法1；
方法2；
……
public void run(){
实现代码
}
}
【三段代码】
第一段代码，就是一个很简单，就是和多线程没有关系的一段测试代码。
第二段代码，使用继承Thread的方法实现多线程。
第三段代码，使用实现Runnable接口的方法实现多线程。
第一段代码：
public class NoThreadTest {
private String noThread1;
public NoThreadTest(){
}
public NoThreadTest(String noThread1){
this.noThread1=noThread1;
}
public void run(){
for(int i=0;i<3;i++){
System.out.println(noThread1+"非多线程运行结果 "+i);
}
}
public static void main(String[] args){
NoThreadTest maintest1=new NoThreadTest("我是A");
NoThreadTest maintest2=new NoThreadTest("我是B");
maintest1.run();
maintest2.run();
}
执行结果：
我是A非多线程运行结果 0
我是A非多线程运行结果 1
我是A非多线程运行结果 2
我是B非多线程运行结果 0
我是B非多线程运行结果 1
我是B非多线程运行结果 2
第二段代码：
public class ThreadTest extends Thread {
private String Thread1;
public ThreadTest(){
}
public ThreadTest(String Thread1){
this.Thread1=Thread1;
}
public void run(){
for(int i=0;i<3;i++){//可以参看评论5进行修改，效果会好一些。
System.out.println(Thread1+"多线程运行结果 "+i);
}
}
public static void main(String[] args){
ThreadTest maintest1=new ThreadTest("我是A");
ThreadTest maintest2=new ThreadTest("我是B");
maintest1.run();
maintest2.run();
System.out.println("..............我是分割线........................");
maintest1.start();
maintest2.start();
}
}
执行结果：(每一次执行的结果都是不一样的，这只是其中的某一种)
我是A多线程运行结果 0
我是A多线程运行结果 1
我是A多线程运行结果 2
我是B多线程运行结果 0
我是B多线程运行结果 1
我是B多线程运行结果 2
..............我是分割线........................
我是A多线程运行结果 0
我是B多线程运行结果 0
我是B多线程运行结果 1
我是B多线程运行结果 2
我是A多线程运行结果 1
我是A多线程运行结果 2
第三段代码:
public class ThreadTest2 implements Runnable {
private String Thread1;
public ThreadTest2(){
}
public ThreadTest2(String Thread1){
this.Thread1=Thread1;
}
public void run(){
for(int i=0;i<3;i++){//可以参看评论5，效果会好一些
System.out.println(Thread1+"多线程运行结果 "+i);
}
}
public static void main(String[] args){
ThreadTest2 maintest1=new ThreadTest2("我是A");
ThreadTest2 maintest2=new ThreadTest2("我是B");
Thread maintest4=new Thread(maintest1);
Thread maintest5=new Thread(maintest2);
maintest1.run();
maintest2.run();
System.out.println("..............我是分割线1........................");
maintest4.run();
maintest5.run();
System.out.println("..............我是分割线2........................");
maintest4.start();
maintest5.start();
}
}
执行结果：(每一次执行的结果都是不一样的，这只是其中的某一种)
我是A多线程运行结果 0
我是A多线程运行结果 1
我是A多线程运行结果 2
我是B多线程运行结果 0
我是B多线程运行结果 1
我是B多线程运行结果 2
..............我是分割线1........................
我是A多线程运行结果 0
我是A多线程运行结果 1
我是A多线程运行结果 2
我是B多线程运行结果 0
我是B多线程运行结果 1
我是B多线程运行结果 2
..............我是分割线2........................
我是B多线程运行结果 0
我是B多线程运行结果 1
我是B多线程运行结果 2
我是A多线程运行结果 0
我是A多线程运行结果 1
我是A多线程运行结果 2
【代码分析】
1. run方法和start方法的区别：
java核心技术中有这样一段话：不要调用Thread类或Runnable对象的run方法。直接调用run方法，只会执行同一个线程中的任务，而不会启动新线程。应该调用Thread.start方法。这个方法将创建一个执行run方法的新线程。
2. 在上面第三段代码中，ThreadTest2类，Thread类和Runnerable接口都实现了run方法。
1)Runnerable接口实现run方法
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
2)Thread类实现run方法。
public void run() {
if (target != null) {
target.run();
}
}
3)为什么要说这个？因为这个实现是使用了代理模式。
代理:一个角色代表另一个角色来完成某些特定的功能。
举个例子：大家都买过衣服，所以在买衣服的时候，一般有下面的角色：
购物者：我们一般是从代理商那里买衣服，我们并不和制造商进行交涉，我们不关心衣服是如何生产出来的。
代理商：代理商是从制造商那里拿衣服，并且代理商可以提供一些简单的服务，比如裁剪裤子等。
制造商：制造衣服，并且批发衣服给代理商。
我们从上面的行为中可以抽象出，一个行为就是卖衣服这个行为在代理商和制造商都有，如果购物者要买衣服，也需要以代理商和制造商卖衣服为前提。
从上面我们可以抽象出三个角色，并不是和上面对应的哈。
抽象主题角色：这个使我们可以抽象出来的角色。就是卖衣服这个行为。
代理主题角色：中间商。
实际被代理角色：制造商。
代码：
SellClothes.java(需要和接口名一样)
//抽象主题角色：买衣服
public interface SellClothes {
void sellClothes();
}
Middleman.java
//代理主题角色：中间商
public class Middleman implements SellClothes{
private SellClothes t;
public Middleman(SellClothes t) {
super();
this.t = t;
}
public void sellClothes() {
t.sellClothes();
System.out.println("我是中间商，我买的是制造商的衣服");
System.out.println("我是中间商，我还提供对裤子不合适的进行裁剪服务");
}
}
SellClothes.java
//实际被代理角色
public class Manufacturer implements SellClothes{
public void sellClothes() {
System.out.println("我是制造商，我提供批发衣服服务");
}
}
Test.java
public class Test {
public static void main(String[] args) {
Manufacturer t = new Manufacturer();
Middleman sellclothes = new Middleman(t);
sellclothes.sellClothes();
}
}
运行结果：
我是制造商，我提供批发衣服服务
我是中间商，我买的是制造商的衣服
我是中间商，我还提供对裤子不合适的进行裁剪服务
得出结论：
抽象主题角色：Runnable，提供run方法
代理主题角色：Thread类，提供run方法
实际被代理角色：ThreadTest2，也实现了run 方法
3. native关键字
在看到start()实现方法的时候，看到了如下一段代码：
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)
throw new IllegalThreadStateException();
group.add(this);
start0();
if (stopBeforeStart) {
stop0(throwableFromStop);
}
}
private native void start0();
native是什么关键字：
一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现
【实现区别】
1. 三段代码
1)第一段：
public class ThreadTest6 extends Thread {
private int num=3;//定义飞机票的张数
public void run(){
for(int i=0;i<10;i++){
if(num>0){
System.out.println(Thread.currentThread().getName()+"飞机票还剩余num= "+num--);
}
}
}
public static void main(String[] args){
ThreadTest6 threadtest1=new ThreadTest6();
ThreadTest6 threadtest2=new ThreadTest6();
ThreadTest6 threadtest3=new ThreadTest6();
threadtest1.start();
threadtest2.start();
threadtest3.start();
}
}
结果：
Thread-1飞机票还剩余num= 3
Thread-2飞机票还剩余num= 3
Thread-2飞机票还剩余num= 2
Thread-2飞机票还剩余num= 1
Thread-0飞机票还剩余num= 3
Thread-0飞机票还剩余num= 2
Thread-0飞机票还剩余num= 1
Thread-1飞机票还剩余num= 2
Thread-1飞机票还剩余num= 1
2)第二段：
public class ThreadTest5 implements Runnable {
private int num=3;//定义飞机票的张数
public void run(){
for(int i=0;i<10;i++){
if(num>0){
System.out.println(Thread.currentThread().getName()+"飞机票还剩余num= "+num--);
}
}
}
public static void main(String[] args){
ThreadTest5 threadtest1=new ThreadTest5();
ThreadTest5 threadtest2=new ThreadTest5();
ThreadTest5 threadtest3=new ThreadTest5();
Thread thread1=new Thread(threadtest1,"窗口1");
Thread thread2=new Thread(threadtest2,"窗口2");
Thread thread3=new Thread(threadtest3,"窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
结果：
窗口2飞机票还剩余num= 3
窗口2飞机票还剩余num= 2
窗口2飞机票还剩余num= 1
窗口1飞机票还剩余num= 3
窗口1飞机票还剩余num= 2
窗口1飞机票还剩余num= 1
窗口3飞机票还剩余num= 3
窗口3飞机票还剩余num= 2
窗口3飞机票还剩余num= 1
3)第三段：
public class ThreadTest7 implements Runnable {
private int num=3;//定义飞机票的张数
public void run(){
for(int i=0;i<10;i++){
if(num>0){
System.out.println(Thread.currentThread().getName()+"飞机票还剩余num= "+num--);
}
}
}
public static void main(String[] args){
ThreadTest7 threadtest1=new ThreadTest7();
Thread thread1=new Thread(threadtest1,"窗口1");
Thread thread2=new Thread(threadtest1,"窗口2");
Thread thread3=new Thread(threadtest1,"窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
结果：
窗口1飞机票还剩余num= 3
窗口1飞机票还剩余num= 2
窗口1飞机票还剩余num= 1
2. 分析：
第一和第二段代码不管是使用Runnerable实现还是使用Thread实现，从结果可以看出三个线程每个线程均有num这个资源，如果把num看做是飞机票的话，那么每个线程都有三张飞机票。这不是我们实际中要得到的情况。
要实现这个飞机售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。
这就是第三段代码实现的结果，ThreadTest7只创建了一个资源对象——threadtest1。创建了三个线程，每个线程调用的是同一个threadtest1对象中的run()方法，访问的是同一个对象中的变量（num）的实例，这个程序满足了我们的需求。
3. 结论：
可见，实现Runnable接口相对于继承Thread类来说，有如下显著的好处：
(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。
(2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。
(3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。
java多线程的认识
猜你喜欢
转载自www.cnblogs.com/Sky-Raining/p/10279810.html
今日推荐
周排行