线程和进程
- 进程:在操作系统中能(同时)运行多个任务(程序),每一个应用程序就是进程。
- 线程:在一个程序中同时运行额多个独立流程,每一个独立的流程就是一个线程。
- 每一个Java程序都至少有一个线程–主线程,当一个Java程序启动时,JVM会创建这个主线程,并且在这个主线程上调用main()方法。
- 线程并发:多个线程同时执行(多个线程轮流分配cpu的时间片,并不是真正的同时执行)。
线程开发
- 线程开发有两种方式:
- 继承Thread类
- 实现Runnable接口
继承Thread类
继承Thread类开发线程
- 用户定义一个类继承Thread类
- 覆盖run方法
运行线程
class MyThread extends Thread{ public void run(){ for(int i =1; i<=1000; i++) { System.out.println(i+"$$$"); } } } class MyThread2 extends Thread{ public void run() { for(int i=1; i<=1000; i++) { System.out.println(i+"###"); } } }
public class TestThread {
public static void main(String args[]) {
Thread t1 = new MyThread1();
Thread t2 = new MyThread2();
//启动线程,输出顺序是随机的
t1.start();
t2.start();
}
}
实现Runnable接口
- Runnable接口开发线程
- 用户开发一个类实现Runnable接口
- 实现run();
- 运行线程
Runnable target = newMyRunnable2();
Thread t2 = new Thread(target);
示例
class MyThread1 extends Thread {
public void run() {
for(int i = 1; i<=1000; i++ ) {
System.out.pintln(i+"$$$");
}
}
}
class MyRunnable2 implements Runnable {
public void run() {
for(int i = 1; i<=1000; i++) }
System.out.println(i+"###");
}
}
}
public class TestThread {
//第一种方式
Thread t1 = new MyRunnable1();
//第二种方式
Runnable target = new MyRunnale2();
Thread t2 = new Thread(target);
t1.start();
t2.start();
}
}
两种方式对比
- 继承Thread上面向对象的编程方式
- 实现Runnable接口解决了单一继承的限制
二者都可采用匿名内部类的方式,如果线程只在一处使用,可以选择这种方式,但是可读性较差。
new Thread() { @Override public void run() { for(int i = 1; i<=1000; i++) { System.out.println(i+"$$$"); } } }.start(); new Thread(new Runnable() { @Overrider public void run() { for(int i = 1; i<=1000; i++) { System.out.println(i+"###"); } } }).start();
线程的状态
- 线程的状态分为5种,初始、可运行、运行、阻塞、以及终止等。
线程的调度与控制
- 通常我们的计算机知识一个CPU,CPU在某一个时刻只能执行一条指令,线程知识得到CPU时间片,也就是使用权,才可以执行指令。在单CPU的机器上线程不是并行运行的,只有在多个CPU的使用权,目前按有两种调度模型:分时调度模型和抢占式调度模型,Java使用抢占式调度模型。
- 分时调度模型,所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU时间片。
- 抢占式调度模型,优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个。
线程优先级
线程优先级主要分三种
- MAX_PRIORITY(最高级);
- MIN_PRIOITY(最低级);
NOM_PRIORITY(标准)默认;
public class ThreadTest04 { public static void main(String[] args) { Runnable r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); //设置线程的优先级,线程启动后不能再次设置优先级 //必须在启动前设置优先级 //设置最高优先级 t1.setPriority(Thread.MAX_PRIORITY); //启动线程 t1.start(); //取得线程名称 //System.out.println(t1.getName()); Thread t2 = new Thread(r1, "t2"); //设置最低优先级 t2.setPriority(Thread.MIN_PRIORITY); t2.start(); System.out.println(Thread.currentThread().getName()); } }
class Processor implements Runnable {
public void run() {
for (int i=0; i<100; i++) {
System.out.println(Thread.currentThread().getName() + "," + i);
}
}
}
/**
*从输出结果应该看可以看出,
*优先级高的线程(t1)会得到的
*CPU时间多一些,优先执行完成
**/
sleep和join还有yeild
Thread.sleep
sleep设置休眠的时间,单位毫秒,当一个线程遇到sleep的时候,就会睡眠,进入到阻塞状态,放弃CPU,腾出cpu时间片,给其他线程用,所以在开发中通常我们会这样做,使其他的线程能够取得CPU时间片,当睡眠时间到达了,线程会进入就绪状态,得到CPU时间片继续执行,如果线程在睡眠状态被中断了,将会抛出IterruptedException
public class ThreadTest05 { public static void main(String[] args) { Runnable r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); t1.start(); Thread t2 = new Thread(r1, "t2"); t2.start(); } } class Processor implements Runnable { public void run() { for (int i=0; i<100; i++) { System.out.println(Thread.currentThread().getName() + "," + i); if (i % 10 == 0) { try { //睡眠100毫秒,主要是放弃CPU的使用,将CPU时间片交给其他线程使用 Thread.sleep(100); }catch(InterruptedException e) { e.printStackTrace(); } } } }
}
Thread.join
当前线程可以调用另一个线程的join方法,调用后当前线程会被阻塞不再执行,直到被调用的线程执行完毕,当前线程才会执行
public class ThreadTest07 { public static void main(String[] args) { Runnable r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); t1.start(); try { t1.join(); }catch(InterruptedException e) { e.printStackTrace(); } System.out.println("------main end-------"); } } class Processor implements Runnable { public void run() { for (int i=0; i<10; i++) { System.out.println(Thread.currentThread().getName() + "," + i); } } }
Thread.yield
它与sleep()类似,只是不能由用户指定暂定多长时间,并且yield()方法只能让同优先级的西安城有执行的机会。
public class ThreadTest06 { public static void main(String[] args) { Runnable r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); t1.start(); Thread t2 = new Thread(r1, "t2"); t2.start(); } } class Processor implements Runnable { public void run() { for (int i=0; i<100; i++) { System.out.println(Thread.currentThread().getName() + "," + i); if (i % 10 == 0) { System.out.println("--------------"); //采用yield可以将CPU的使用权让给同一个优先级的线程 Thread.yield(); } } } }
sleep、join、yeild关系
- sleep()使当前线程进入停滞状态,所以执行sleep的线程在指定的时间内肯定不会执行;sleep()可使优先级低的线程得到执行的机会,当然也可以让同优先级和高优先级的线程有执行的机会。
- join方法也会导致线程阻塞
- 特点:如果当前线程中调用了另外一个线程的join方法,单签线程会立即阻塞,直到另外一个线程运行完成。
- yield()只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行,yield()只能使同优先级的线程有执行的机会。
interrupt(中断)
如果我们的线程正在睡眠,可以采用interrupt进行中断
public class ThreadTest08 { public static void main(String[] args) { Runnable r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); t1.start(); try { //设置为500毫秒,没有出现中断异常,因为500毫秒之后再次调用t1.interrupt()时, //此时的睡眠线程已经执行完成 //如果sleep的时间设置的小一些,会出现中断异常,因为存在睡眠线程 Thread.sleep(500); }catch(Exception e) { e.printStackTrace(); } //中断睡眠中的线程 t1.interrupt(); } } class Processor implements Runnable { public void run() { for (int i=1; i<100; i++) { System.out.println(Thread.currentThread().getName() + "," + i); if (i % 50 == 0) { try { Thread.sleep(200); }catch(Exception e) { System.out.println("-------中断-------"); break; } } } } }
如何正确的停止一个线程
通常定义一个标记,来判断标记的状态停止线程的执行。
public class ThreadTest09 { public static void main(String[] args) { //Runnable r1 = new Processor(); Processor r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); t1.start(); try { Thread.sleep(20); }catch(Exception e) {} //停止线程 r1.setFlag(true); } } class Processor implements Runnable { //线程停止标记,true为停止 private boolean flag; public void run() { for (int i=1; i<100; i++) { System.out.println(Thread.currentThread().getName() + "," + i); //为true停止线程执行 if (flag) { break; } } } public void setFlag(boolean flag) { this.flag = flag; } }
为什么需要同步
【示例代码】,取得0~10的和采用相同的线程对象启用两个线程进行计算(共享一个对象启动两个线程)
public class ThreadTest10 { public static void main(String[] args) { Runnable r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); t1.start(); Thread t2 = new Thread(r1, "t2"); t2.start(); } } class Processor implements Runnable { public void run() { //定义局部变量s,作为累加变量 int s = 0; for (int i=0; i<10; i++) { s+=i; } System.out.println(Thread.currentThread().getName() + ", s=" + s); } }
以上t1和t2并发执行,s为每个线程的局部变量,位于各自的栈帧中,因为栈帧中的数据是不会互相干扰的,所有计算结果都为45
线程同步
【示例代码】,取得0~10的和采用两个线程进行计算,将s改为成员变量(共享一个对象启动两个线程)
public class ThreadTest11 { public static void main(String[] args) { Runnable r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); t1.start(); Thread t2 = new Thread(r1, "t2"); t2.start(); } } class Processor implements Runnable { //定义成员变量s,作为累加变量 private int s = 0; public void run() { for (int i=0; i<10; i++) { s+=i; } System.out.println(Thread.currentThread().getName() + ", s=" + s); } }
这回两个线程的结果不一致了。为什么出现以上的问题,因为共享了同一个对象的成员变量s,两个线程同时对其进行操作,所以产生了问题,此时称为此时Processor为线程不安全的,如果想得到正确的结果,必须采用线程同步,加锁,该变量才能共享使用
- 产生数据不一致的原因
- 多个线程并发访问了同一个对象,如果破坏了不可分割的操作,从而就会造成数据不一致
- 临界资源
- 原子操作
- 被多线程并发访问时如果一个对象有可能出现数据不一致的问题,那么这个对象称为线程不安全的对象
使用线程同步
线程同步,指某一个时刻,指允许一个线程来访问共享资源,线程同步其实是对对象加锁,如果对象中的方法都是同步方法,那么某一时刻只能执行一个方法,采用线程同步解决以上的问题,我们只要保证线程1操作s时,线程2不允许操作即可,只有线程1使用完成s后,再让线程2使用s变量。
public class ThreadTest12 { public static void main(String[] args) { Runnable r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); t1.start(); Thread t2 = new Thread(r1, "t2"); t2.start(); } } class Processor implements Runnable { //定义成员变量s,作为累加变量 private int s = 0; //synchronized是对对象加锁,采用synchronized同步最好只同步有线程安全的代码 //可以优先考虑使用synchronized同步块因为同步的代码越多,执行的时间就会越长, //其他线程等待的时间就会越长影响效率 //public synchronized void run() { //使用同步块 synchronized (this) { for (int i=0; i<10; i++) { s+=i; } System.out.println(Thread.currentThread().getName() + ", s=" + s); s = 0; } } }
执行正确 ,以上示例,如果不采用线程同步如何解决?可以让每个线程创建一个对象,这样在堆中就不会出现对象的状态共享了,从而可以避免线程安全问题
线程同步后的状态
为每一个线程创建一个对象来解决线程安全问题
public class ThreadTest13 {
public static void main(String[] args) {
Runnable r1 = new Processor();
Thread t1 = new Thread(r1, "t1");
t1.start();
//再次创建Processor对象,每个线程拥有自己的对象
Runnable r2 = new Processor();
Thread t2 = new Thread(r2, "t2");
t2.start();
}
}
class Processor implements Runnable {
//定义成员变量s,作为累加变量
private int s = 0;
public void run() {
for (int i=0; i<10; i++) {
s+=i;
}
System.out.println(Thread.currentThread().getName() + ", s=" + s);
s = 0;
}
}
死锁
synchronized(a){
...//1
synchronized(b){
}
}
synchronized(b){
... //2
synchronized(a){
}
}
解决死锁
一般我们借助于线程的通信解决死锁问题
synchronized(a){ ...//1 wait(); synchronized(b){ } } synchronized(b){ ... //2 synchronized(a){ notify(); } }
解决死锁的案例
线程状态
守护线程
从线程分类可以分为:
- 用户线程(以上讲的都是用户线程)
守护线程。守护线程是这样的,所有的用户线程结束生命周期,守护线程才会结束生命周期,只要有一个用户线程存在,那么守护线程就不会结束,例如java中著名的垃圾回收期就是一个守护线程,只有应用程序中所有的线程结束,它才会结束。
public class DaemonThreadTest01 { public static void main(String[] args) { Runnable r1 = new Processor(); Thread t1 = new Thread(r1, "t1"); t1.start(); for (int i=0; i<10; i++) { System.out.println(Thread.currentThread().getName() + ", " + i); } System.out.println("主线程结束!!!"); } } class Processor implements Runnable { public void run() { for (int i=0; i<10; i++) { System.out.println(Thread.currentThread().getName() + ", " + i); } } }
主线程执行结束了,但用户线程仍然将数据打印出来了
守护(服务线程)线程示例
public class DaemonThreadTest02 {
public static void main(String[] args) {
Runnable r1 = new Processor();
Thread t1 = new Thread(r1, "t1");
//将当前线程修改为守护线程,在线程没有启动时可以修改以下参数
t1.setDaemon(true);
t1.start();
for (int i=0; i<10; i++) {
System.out.println(Thread.currentThread().getName() + ", " + i);
}
System.out.println("主线程结束!!!");
}
}
class Processor implements Runnable {
public void run() {
for (int i=0; i<10; i++) {
System.out.println(Thread.currentThread().getName() + ", " + i);
}
}
}