Java基础回顾之——多线程1

 如果程序每次只能做一件事情，未免为太单调，所以，java中引入了多线程，能让程序同时处理很多事情。例如，当我们发起一次网络请求的时候。如果网速慢，服务器有可能不会立刻给我们返回数据，这时候，如果不放在子线程中去处理，则会导致主线程被阻塞，从未影响软件的正常使用。下面，开始回顾java中的多线程相关知识点。

一.实现线程的方法

 1.1继承Thread类
  新建一个类，继承Thread，然后重写父类中的run()方法。在run()方法中写具体的实现功能，如下：
 public class YyqThread extends Thread{
@Override
public void run() {
//具体处理的逻辑
}
}
 启动这个线程也很简单，new出YyqThread的示例，然后调用它的start()方法。 YyqThread yyqThread = new YyqThread();
yyqThread.start();    1.2实现Runnable接口的方式            相比第一种方法，减少耦合度。这种方式的定义以及启动如下：       public class ImpleThread implements Runnable{
@Override
public void run() {
//具体处理的逻辑

        }

public static void main(String[] args) {ImpleThread impleThread = new ImpleThread();Thread thread = new Thread(impleThread);thread.start();}}说明：新建的时候，实现runnable接口，处理逻辑写在run( )中，启动方式也会不同，新建一个Thread,构造函数中传入runnable的参数，本例中就是impleThread，接着调用Thread的start方法。
    1.3不用实现Runnable接口，可以采用匿名内部内的方法

new Thread(new Runnable() {

@Override
public void run() {
// 具体处理的逻辑
}
}).start();

二.线程的生命周期

线程具有7种生命周期，分别是出生状态，就绪状态，运行状态，等待状态，休眠状态，阻塞状态，死亡状态。
出生状态：当线程被new出来的时候，就是刚创建的时候；
就绪状态：当调用start()方法之后；
运行状态：当线程得到系统资源后；
等待状态：当线程处于运行状态中，调用wait()方法后；当进入等待状态的线程，只有调用Thread的notify()方法才会被唤醒；
休眠状态：当调用sleep()方法之后；
阻塞状态：当线程在运行状态时，发出输入/输出请求的时候，进入阻塞状态，等待输入/输出结束之后，线程进入就绪状态；
死亡状态：让run()方法执行完毕，线程进入死亡状态。

三.线程的其他方法

3.1线程的休眠
调用sleep()方法，指定的参数表示休眠的时间，单位为毫秒
3.2线程的join()方法
两个线程A 和 B，当需要B线程执行完毕之后，才能执行A线程，就可以在A线程中用ThreadB.join()方法。
Demo以及结果：public class ThreadJoin {
//线程A的定义
Thread threadA = new Thread( new ThreadA());
public class ThreadA impl
4000
ements Runnable{
@Override
public void run() {
System.out.println("I am ThreadA, waiting for ThreadB finished....");
try {
threadB.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("I am ThreadA, ThreadB has finished!");
}
}

//线程B的定义
Thread threadB = new Thread( new ThreadB());
public class ThreadB implements Runnable{
@Override
public void run() {
System.out.println("ThreadB is running....");
}
}

public static void main(String[] args) {
ThreadJoin threadJoin = new ThreadJoin();
threadJoin.threadA.start();
threadJoin.threadB.start();
}
}
运行结果：
I am ThreadA, waiting for ThreadB finished....
ThreadB is running....
I am ThreadA, ThreadB has finished!

可以看出，当在线程A中调用线程B的join方法，确实会等待B线程执行完毕之后，才会继续执行A线程。

3.2线程的中断

注意：stop()方法是可以由一个线程去停止另外一个线程，线程A调用线程B的stop方法去停止线程B，调用这个方法的时候线程A其实并不知道线程B执行的具体情况，这种突然间地停止会导致线程B的一些清理工作无法完成，还有一个情况是执行stop方法后线程B会马上释放锁，这有可能会引发数据不同步问题。基于以上这些问题，stop()方法被抛弃了。
所以，出现了interrupt()方法，这个方法不会真正停止一个线程，仅仅是给线程设立了停止标志位。然后让线程自己去结束自己。
DEMO演示：

public class InterruptTHread {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
boolean isContinue = false;//设立中断标志位，默认值false
@Override
public void run() {
long time = System.currentTimeMillis();//记录线程刚执行的时间

// TODO Auto-generated method stub
while(true) {
System.out.println("hello");
long time1 = System.currentTimeMillis();//记录每次打印hello完之后的时间
if(time1 - time  > 1000) {
isContinue = true;//1s过后，设置标志位为true，线程不再执行。
}
if(isContinue)
break;
}
}
});
thread.start();
}
}

程序说明：线程打印“hello”1s，1秒过后，设置标志位为true，跳出循环，不再打印。

这篇文章主要介绍了java线程的基础，包括，线程的定义，实现方法，生命周期，常见方法。
下一篇中，将会介绍java线程中的优先级以及同步的问题