java多线程初学者入门必读

 

OS 分1.单进程 ，如 Dos， 同一时间段，只能运行一个程序；2.多进程，如windows，；同一时间段有多个程序执行，同一个时间点只有一个程序运行；
线程是在进程的基础上划分的；
进程消失了，则线程必然消失，反之未然！
java是多线程操作语言；
实现多线程的方式：
1. 继承Thread类， Thread类属于java.lang；
一个类继承了Thread类，同时覆写了run方法，就实现了多线程，不过启动要用start方法，
2.实现Runnable接口；

————实例

package com.mldn;

 

/*

第一种方式实现多线程： 1.继承Thread，2.覆写run方法；

*/

class MyThread extends Thread // 1.继承Thread类

{

private String name;

 

public MyThread(String name)

{

this.name = name;

}

 

public void run() // 2. 覆写方法，

{

for (int x = 0; x < 50; x++)

{

System.out.println(“当前执行线程：” + this.name + “循环第” + (x+1) + “次”);

}

}

}

 

public class ThreadDemo

{

public static void main(String[] args)

{

MyThread mt1 = new MyThread(“线程A”); // 创建线程

MyThread mt2 = new MyThread(“线程B”);

 

//mt1.run(); // 执行覆写方法，启动线程

//mt2.run();

 

/*

当前执行线程：线程A循环第45次

当前执行线程：线程A循环第46次

当前执行线程：线程A循环第47次

当前执行线程：线程A循环第48次

当前执行线程：线程A循环第49次

当前执行线程：线程A循环第50次

当前执行线程：线程B循环第1次

当前执行线程：线程B循环第2次

当前执行线程：线程B循环第3次

当前执行线程：线程B循环第4次

当前执行线程：线程B循环第5次

当前执行线程：线程B循环第6次

发现直接调用run方法，线程并没有实现同步交互式运行；而是先执行完A 才执行B ，；

 

由java文档可知： 需要调用start()方法，通知jvm启动线程同步！

*/

 

mt1.start();

mt2.start(); // 抢占式执行；

}

}

————-解析：为什么只有调用start方法后，才能通过jvm启动线程的交互执行那？
所有的OS：windows，linux，UNIX，对cpu资源的调度，是由os底层函数完成的，实现多线程操作即是对进行cpu资源的抢占，
即等待cpu调度，这是java程序 无法实现的，java设计者定义了native关键字，表示可调用OS底层函数，这种技术成为：JNI技术；
（Java Native Interface）原生接口！

start方法执行时，系统将默认调用run方法。

public sychronized void started()

{

if (started) // if started

throw new IllegalThreadStateException;

started = true; // if not started , change state

start0();

}

 

prvate native void start0(); // use native keywords , no without 方法体！

但是这种实现方式有个局限：
当一个类既要实现多线程又要继承另一个类时，就不行了，因为类有单继承限制；此时要用第二种方式：

public interface Runnable

{

public void run();

}

Thread类有构造方法:
public Thread(Runnable target); accepts child class of Runnable
————实例二：

package com.mldn;

 

/*

第一种方式实现多线程： 1.继承Thread，2.覆写run方法；3.实例化Thread子类，4.调用start方法

*/

class MyThread extends Thread // 1.继承Thread类

{

private String name;

 

public MyThread(String name)

{

this.name = name;

}

 

public void run() // 2. 覆写方法，

{

for (int x = 0; x < 50; x++)

{

System.out.println(“当前执行线程：” + this.name + “循环第” + (x+1) + “次”);

}

}

}

 

/*

第二种方式实现多线程： 1.实现Runnable接口，2.覆写run方法，3.实例化Runnable，并实例化Thread 4. 调用start方法

*/

class MyRunnable implements Runnable // 1.实现Runnable接口

{

private String name;

 

public MyRunnable(String name)

{

this.name = name;

}

 

public void run() // 2. 覆写方法，

{

for (int x = 0; x < 50; x++)

{

System.out.println(“当前执行线程：” + this.name + “循环第” + (x+1) + “次”);

}

}

}

 

public class ThreadDemo

{

public static void main(String[] args)

{

MyRunnable mt1 = new MyRunnable(“线程A”); //3. 创建线程

MyRunnable mt2 = new MyRunnable(“线程B”);

 

new Thread(mt1).start(); // 4. 调用Thread类的构造方法，用Runnable接口子类的实例实现Thread实例，并调用start方法启动线程！

new Thread(mt2).start();

}

}

————比较两种方式：

Runnable接口更实用：
1.避免单继承，可以实现多个接口；
2.适合资源的共享；

package com.mldn;

 

class Ticket extends Thread

{

private int ticket = 5;

private String name;

 

public Ticket(String name)

{

this.name = name;

}

 

public void run()

{

for (int x = 0; x < 50; x++)

{

if (this.ticket > 0)

{

System.out.println(this.name + “！！！Thread卖票,ticket = ” + this.ticket–);

}

}

}

}

 

class Ticket1 implements Runnable

{

private int ticket = 5;

private String name;

 

public Ticket1(String name)

{

this.name = name;

}

 

public void run()

{

for (int x = 0; x < 50; x++)

{

if (this.ticket > 0)

{

System.out.println(this.name + “卖票,ticket = ” + this.ticket–);

}

}

}

}

 

 

public class TicketDemo

{

public static void main(String[] args)

{

Ticket thread1 = new Ticket(“线程A”);

Ticket thread2 = new Ticket(“线程B”);

Ticket thread3 = new Ticket(“线程C”);

 

thread1.start(); // 三个线程

thread2.start();

thread3.start();

 

/* administrator@xu-desktop:~$ javac -d . ./work/TicketDemo.java

administrator@xu-desktop:~$ java com.mldn.TicketDemo

线程A卖票,ticket = 5

线程A卖票,ticket = 4

线程A卖票,ticket = 3

线程A卖票,ticket = 2

线程A卖票,ticket = 1

线程B卖票,ticket = 5

线程B卖票,ticket = 4

线程B卖票,ticket = 3

线程B卖票,ticket = 2

线程B卖票,ticket = 1

线程C卖票,ticket = 5

线程C卖票,ticket = 4

线程C卖票,ticket = 3

线程C卖票,ticket = 2

线程C卖票,ticket = 1

 

发现三个线程各卖各的票，而票只有5张，没有实现资源共享

*/

 

// 测试由第二种方案实现的多线程：

 

Runnable thr = new Ticket1(“线程A”);

 

 

new Thread(thr).start(); // 三个线程共享一个接口实例，

new Thread(thr).start();

new Thread(thr).start();

/*

线程A卖票,ticket = 5

线程A卖票,ticket = 4

线程A卖票,ticket = 3

线程A卖票,ticket = 2

线程A卖票,ticket = 1

 

*/

}

}

/*
        联系： Thread 代理实现Runnable接口的子类去实现 多线程！
*/

 

声明: 除非转自他站（如有侵权，请联系处理）外，本文采用 BY-NC-SA 协议进行授权 | 嗅谱网
转载请注明：转自《java多线程初学者入门必读》
本文地址：http://www.xiupu.net/archives-66.html
关注公众号：

赞赏

微信赞赏支付宝赞赏