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
{
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
{
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
{
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
{
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
{
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多线程初学者入门必读》
本文地址：https://www.zhiletu.com/archives-66.html
关注公众号：
微信赞赏
支付宝赞赏
鲁公网安备 37011302000311号
