1.线程中常用的方法介绍
CLASS:Thread类【java.lang.Thread】
INTERFACE:Runnable【java.lang.Runnable】
里面都有一个方法，因为Thread也实现了Runnable接口
public abstract void run();//Runnable@Overridepublic void run() {//Thread if (target != null) { target.run(); }}
CLASS:Thread类【java.lang.Thread】常用方法
1.线程的创建(构造函数)
a: Thread()
b: Thread(String name)
c: Thread(Runnable target)
d: Thread(Runnable target,String name)
2.线程里面的方法
a: void start() 启动线程
b: static void sleep(Long millis) 线程休眠
c: static void sleep(Long millis,int nanos) 线程休眠
d: void join() 使其他线程等待当前线程终止 不带参数说明所有线程都进行等待
e: void join(Long millis) 使其他线程等待当前线程终止 带参数说明其他线程最长需要等待的时候
f: void join(Long millis,int nanos) 使其他线程等待当前线程终止 带参数说明其他线程最长需要等待的时候
g: static void yield() 当前运行线程释放资源
h: static Thread currentThread() 返回当前运行的线程引用
2.线程的基本实现
场景：我是农村人，我妈妈是一个节俭的人。虽然现在条件好了，我妈妈不要干农活了，但是我妈妈在帮我姐姐带小孩的时候还天天去旁边的服装厂剪线头，我听妈妈说，服装厂来活的时候员工们都抢着去拿服装，抢货，因为是记件的，所以抢得越多赚的就越多，我们就来模拟这样一个场景。
第一种方式
package com.example.learning.多线程;/** * 描述： * User: 曾远征 * Date: 2018-09-17 * Time: 21:02 */public class EmployeeAThread extends Thread {//第一种方式，继承Thread @Override public void run() {//重写run方法 System.out.println(getName()+"我是一个员工"); int count=0; boolean isBoolean=true; while (isBoolean){ System.out.println(getName()+"我在拿货,拿了"+(++count)+"件"); if (count==100){ isBoolean=false; } if (count%5==0){ try { sleep(3000);//休息3秒 } catch (InterruptedException e) { e.printStackTrace(); } } } System.out.println(getName()+"我拿完货了"); } public static void main(String[] args) { Thread thread=new EmployeeAThread(); thread.setName("大金牙"); thread.start(); }}
第二种方式
package com.example.learning.多线程;/** * 描述： * User: 曾远征 * Date: 2018-09-17 * Time: 21:15 */public class EmployeeBRunnable implements Runnable {//实现Runnable接口 @Override public void run() { System.out.println(Thread.currentThread().getName()+"我是一个员工"); int count=0; boolean isBoolean=true; while (isBoolean){ System.out.println(Thread.currentThread().getName()+"我在拿货,拿了"+(++count)+"件"); if (count==100){ isBoolean=false; } if (count%5==0){ try { Thread.sleep(3000);//休息3秒 } catch (InterruptedException e) { e.printStackTrace(); } } } System.out.println(Thread.currentThread().getName()+"我拿完货了"); } public static void main(String[] args) { Thread thread=new Thread(new EmployeeBRunnable(),"小金牙"); thread.start(); }}
两个线程一起运行
package com.example.learning.多线程;/** * 描述：两个线程一起执行 * User: 曾远征 * Date: 2018-09-17 * Time: 21:19 */public class EmployeeABMain { public static void main(String[] args) { Thread threadA=new EmployeeAThread(); threadA.setName("大金牙"); threadA.start(); Thread threadB=new Thread(new EmployeeBRunnable(),"小金牙"); threadB.start(); }}
结果返回
两个线程交替运行，为什么不是一起执行呢？因为在同一个时间，同一个处理器，只能运行一个线程，但一个线程运行完时才能运行另外一个线程
以上示例在githun地址：
https://github.com/ant-zengyz/Learning/tree/master/src/main/java/com/example/learning/%E5%A4%9A%E7%BA%BF%E7%A8%8B
3.稍微深入的实现线程
package com.example.learning.多线程.多线程模拟2;/** * 描述： * User: 曾远征 * Date: 2018-09-17 * Time: 21:41 */public class EmployeeRunnable implements Runnable { //volatile保证了线程可以正确的读取其他线程写入的值，为什么volatile可以保证，哈哈，我也不懂，但是我知道这样做是可以的，你们百度吧 volatile boolean isBoolean=true; @Override public void run() { while (isBoolean){ for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName()+"我在拿货,拿了"+i+"件"); //让出处理器时间，下次哪条线程执行还是未知数 Thread.yield(); } } System.out.println(Thread.currentThread().getName()+"我拿完货了"); }} package com.example.learning.多线程.多线程模拟2;/** * 描述： * User: 曾远征 * Date: 2018-09-17 * Time: 21:46 */public class FactoryThread extends Thread { @Override public void run() {//重写run方法 EmployeeRunnable djy=new EmployeeRunnable(); EmployeeRunnable xjy=new EmployeeRunnable(); Thread djyThread=new Thread(djy,"大金牙"); Thread xjyThread=new Thread(xjy,"小金牙"); djyThread.start(); xjyThread.start(); //主线程停止，让子线程执行 try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } //让线程停止 djy.isBoolean=false; xjy.isBoolean=false; try { xjyThread.join(); } catch (InterruptedException e) { e.printStackTrace(); } } public static void main(String[] args) { new FactoryThread().start(); }}
执行结果
可以看到，有的时候是一人一次执行，有的时候是一个线程连续执行，为什么呢？因为Thread.yield()方法
3.再次稍微的深入的实现线程（接上一版本进行改造添加）
package com.example.learning.多线程.多线程模拟3;/** * 描述： * User: 曾远征 * Date: 2018-09-17 * Time: 21:41 */public class EmployeeDPZRunnable implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName()+"我在拿货"); for (int i = 0; i < 10 ; i++) { System.out.println(Thread.currentThread().getName()+"仗着自己胖，拼命拿货"); } System.out.println(Thread.currentThread().getName()+"我拿完货了"); }} package com.example.learning.多线程.多线程模拟3;/** * 描述： * User: 曾远征 * Date: 2018-09-17 * Time: 21:46 */public class FactoryThread extends Thread { @Override public void run() {//重写run方法 EmployeeRunnable djy=new EmployeeRunnable(); EmployeeRunnable xjy=new EmployeeRunnable(); Thread djyThread=new Thread(djy,"大金牙"); Thread xjyThread=new Thread(xjy,"小金牙"); djyThread.start(); xjyThread.start(); //主线程停止，让子线程执行 try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } Thread dpzThread=new Thread(new EmployeeDPZRunnable(),"大胖子"); //让线程停止 djy.isBoolean=false; xjy.isBoolean=false; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } dpzThread.start(); //等待线程执行完成 try { dpzThread.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("结束了"); } public static void main(String[] args) { new FactoryThread().start(); }} 输出结果
这里有一个关键方法join()，主线程会等待子线程执行完时才会执行
这里主要就是几个关键的方法的实现，sleep 和 yield 还有 join的用法
列子都在上面的github地址里面，谢谢