[2014-11-19]Java笔记_多线程(Multi-Thread)
2014-11-19 13:50
423 查看
一、 线程/进程 的概念
线程:线程就是程序中单独顺序的流控制。线程本身不能运行,它只能用于程序中。
多线程: 多线程则指的是在 单个程序中可以同时运行多个不同的线程执行不同的任务。
进程:执行中的程序(程序是静态的概念,进程是动态的概念)。
说明:线程是程序内的顺序控制流,只能使用分配给程序的资源和环境。
· Java 中如果我们自己没有产生线程,那么系统就会给我们产生一个线程(主线程,main方法就在主线程上运行),我们的程序都是由线程来执行的。
二、 多线程编程的目的
· 最大限度地利用CPU 资源,当某一线程的处理不需要占用CPU而只和I/O等资源打交道时,让需要占用CPU资源的其他线程有机会获得CPU资源。
三、多线程
· 一个进程可以包含一个或多个线程。
· 一个程序实现了多个代码同时交替运行就需要产生多个线程。
· CPU 随机 的抽出时间,让我们的程序一会做这件事就,一会做另外一件事情。
四、线程的实现
线程的实现有两种方式:第一种方式是继承 Thread 类,然后重写 run 方法;第二种是实现 Runnable 接口,然后实现 run 方法。将我们希望线程执行的代码放到 run 方法中,然后通过 start 方法来启动线程, start 方法首先为线程的执行准备好系统资源,然后再去调用 run 方法。当某个类继承了 Thread 类之后,该类就叫做一个线程类。
· 对于单核 CPU 来说,某一时刻只能有一个线程在执行(微观串行),从宏观角度来看,多个线程在同时进行(宏观并行)。对于双核或双核以上的CPU来说,可以做到真正做到微观并行。
Thread 类源码分析:
1. Thread 类也实现了 Runnable 接口,因此实现了Runnable 接口中的 run 方法;
2. 当生成一个线程对象时,如果没有为其设定名字,那么线程对象的名字将使用如下形式:Thread-number,该number是自动增加的,并被所有的 Thread 对象所共享(因为它是 static 的成员变量)。
3. 当使用第一种方式来生成线程对象时,我们需要重写run 方法,因为 Thread 类的run 方法此时什么事情都不做。当使用第二种方式来生成线程对象时,我们需要实现 Runnable 接口的 run 方法,然后使用 new Thread(new MyThread())(假设MyThread已经实现了runnable接口)来生成线程对象,这时的线程对象 run 方法就会调用 MyThread 类的 run 方法,这样我们自己编写的run方法就执行了。
4.
五、 线程的生命周期
线程的生命周期可分为四个状态: 1. 创建状态; 2. 可运行状态; 3. 不可运行状态; 4. 消亡状态。
·关于成员变量与局部变量: 如果一个变量是成员变量, 那么多个线程对同一个对象的成员变量进行操作时,他们对该成员变量是彼此影响的(也就是说一个线程对成员变量的改变会影响到另一个线程) 。如果一个变量是局部变量,那么每个线程都会有一个该局部变量的拷贝,一个线程对该局部变量的改变不会影响到其他的线程。
·停止线程的方式:不能使用 Thread 类的 stop 方法来终止线程的执行。一般要设定一个变量,在 run 方法中是一个循环,循环每次检查该变量,如果满足条件则继续执行,否则跳出循环,线程结束。
·不能依靠线程的优先级来决定线程的执行顺序。
六、 多线程的同步
在多线程环境中,可能会有两个甚至更多的线程是同时访问一个有限的资源,这样会造成资源的冲突。解决方法:在线程使用一个资源时为其加锁即可。访问资源的第一个线程为其加上锁以后,其他线程便不能再使用那个资源,除非被解锁。
· synchronized 关键字:当 synchronized 关键字修饰一个方法的时候,该方法叫做同步方法。
· Java 中的每个对象都有一个锁(lock)或者叫做监视器(monitor),当访问某个对象的 synchronized 方法时,表示将该对象上锁,此时其他任何线程都无法再去访问该 synchronized 方法了,直到之前的那个线程执行方法完毕后(或者是抛出了异常),那么将该对象的锁释放掉,其他线程才有可能再去访问该 synchronized 方法。
· 如果一个对象有多个 synchronized 方法,某一时刻某个线程已经进入到了某个 synchronized 方法,那么在该方法没有执行完毕前,其他线程都是无法访问该对象的任何 synchronized 方法的。
·如果某个 synchronized 方法是 static 的,那么当线程访问该方法时,它锁的并不是 synchronized 方法所在的对象,而是 synchronized 方法所在的对象所对应的 Class 对象,因为java中无论一个类有多少个对象,这些对象都会对应唯一一个 Class 对象,因此当线程分别访问同一个类的两个对象的
static,synchronized 方法时,他们的执行顺序也是顺序的,也就是说一个线程先去执行方法,执行完毕后另一个线程才开始执行。
· synchronized 块,写法: synchronized(object){.....}。 表示线程在执行的时候会对 object 对象上锁。
·synchronized 方法是中粗粒度的并发控制,某一时刻,只能有一个线程执行该 synchronized 方法;synchronized块则是一种细粒度的并发控制,只会将块中的代码同步,位于方法内、synchronized 块之外的代码是可以被多个线程同时访问到的。
七、 线程间的相互作用
使用wait()、notify()
· wait 与 notify 方法都是定义在 Object 类中,而且是 final 的,因此会被所有的 java 类所继承并且无法重写。这两个方法要求在调用时线程应该已经获得了对象的锁,因此对这两个方法的调用需要放在 synchronized 方法或块当中。当线程执行了 wait 方法时,它会释放掉对象的锁。
·wait 和 sleep 区别:另一个会导致线程暂停的方法就是 Thread 类的 sleep 方法,它会导致线程睡眠指定的毫秒数,但线程在睡眠过程中是不会释放掉对象的锁的。
线程:线程就是程序中单独顺序的流控制。线程本身不能运行,它只能用于程序中。
多线程: 多线程则指的是在 单个程序中可以同时运行多个不同的线程执行不同的任务。
进程:执行中的程序(程序是静态的概念,进程是动态的概念)。
说明:线程是程序内的顺序控制流,只能使用分配给程序的资源和环境。
· Java 中如果我们自己没有产生线程,那么系统就会给我们产生一个线程(主线程,main方法就在主线程上运行),我们的程序都是由线程来执行的。
二、 多线程编程的目的
· 最大限度地利用CPU 资源,当某一线程的处理不需要占用CPU而只和I/O等资源打交道时,让需要占用CPU资源的其他线程有机会获得CPU资源。
三、多线程
· 一个进程可以包含一个或多个线程。
· 一个程序实现了多个代码同时交替运行就需要产生多个线程。
· CPU 随机 的抽出时间,让我们的程序一会做这件事就,一会做另外一件事情。
四、线程的实现
线程的实现有两种方式:第一种方式是继承 Thread 类,然后重写 run 方法;第二种是实现 Runnable 接口,然后实现 run 方法。将我们希望线程执行的代码放到 run 方法中,然后通过 start 方法来启动线程, start 方法首先为线程的执行准备好系统资源,然后再去调用 run 方法。当某个类继承了 Thread 类之后,该类就叫做一个线程类。
package com.bob.thread; public class ThreadTest { public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread2 t2 = new Thread2(); t1.start(); //启动线程,会自动调用run方法 t2.start(); // t2.start(); //结果每次相同。必须使用start方法才会被认为是以线程方式启动 } } class Thread1 extends Thread{ //将需要执行的代码放在run方法中 @Override public void run() { for(int i = 0; i < 10; i++){ System.out.println("hello:" + i); } } } class Thread2 extends Thread{ //将需要执行的代码放在run方法中 @Override public void run() { for(int i = 0; i < 10; i++){ System.out.println("welcome:" + i); } } }· 一个进程至少要包含一个线程。
· 对于单核 CPU 来说,某一时刻只能有一个线程在执行(微观串行),从宏观角度来看,多个线程在同时进行(宏观并行)。对于双核或双核以上的CPU来说,可以做到真正做到微观并行。
package com.bob.thread; public class ThreadTest2 { public static void main(String[] args) { Thread t1 = new Thread(new MyThread()); Thread t2 = new Thread(new MyThread2()); t1.start(); t2.start(); } } class MyThread implements Runnable { @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println("hello:" + i); } } } class MyThread2 implements Runnable { @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println("welcome:" + i); } } }
Thread 类源码分析:
1. Thread 类也实现了 Runnable 接口,因此实现了Runnable 接口中的 run 方法;
2. 当生成一个线程对象时,如果没有为其设定名字,那么线程对象的名字将使用如下形式:Thread-number,该number是自动增加的,并被所有的 Thread 对象所共享(因为它是 static 的成员变量)。
3. 当使用第一种方式来生成线程对象时,我们需要重写run 方法,因为 Thread 类的run 方法此时什么事情都不做。当使用第二种方式来生成线程对象时,我们需要实现 Runnable 接口的 run 方法,然后使用 new Thread(new MyThread())(假设MyThread已经实现了runnable接口)来生成线程对象,这时的线程对象 run 方法就会调用 MyThread 类的 run 方法,这样我们自己编写的run方法就执行了。
4.
五、 线程的生命周期
线程的生命周期可分为四个状态: 1. 创建状态; 2. 可运行状态; 3. 不可运行状态; 4. 消亡状态。
package com.bob.thread; public class ThreadTest3 { public static void main(String[] args) { Runnable r = new HelloThread(); Thread t1 = new Thread(r); //r = new HelloThread(); Thread t2 = new Thread(r); t1.start(); t2.start(); } } class HelloThread implements Runnable { int i; @Override public void run() { int i = 0; while(true) { System.out.println("number: " + this.i++); try { Thread.sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) { e.printStackTrace(); } if(50 == this.i) { break; } } } }
·关于成员变量与局部变量: 如果一个变量是成员变量, 那么多个线程对同一个对象的成员变量进行操作时,他们对该成员变量是彼此影响的(也就是说一个线程对成员变量的改变会影响到另一个线程) 。如果一个变量是局部变量,那么每个线程都会有一个该局部变量的拷贝,一个线程对该局部变量的改变不会影响到其他的线程。
·停止线程的方式:不能使用 Thread 类的 stop 方法来终止线程的执行。一般要设定一个变量,在 run 方法中是一个循环,循环每次检查该变量,如果满足条件则继续执行,否则跳出循环,线程结束。
·不能依靠线程的优先级来决定线程的执行顺序。
六、 多线程的同步
在多线程环境中,可能会有两个甚至更多的线程是同时访问一个有限的资源,这样会造成资源的冲突。解决方法:在线程使用一个资源时为其加锁即可。访问资源的第一个线程为其加上锁以后,其他线程便不能再使用那个资源,除非被解锁。
· synchronized 关键字:当 synchronized 关键字修饰一个方法的时候,该方法叫做同步方法。
package com.bob.thread; public class ThreadTest4 { public static void main(String[] args) { Example example = new Example(); Thread t1 = new TheThread(example); example = new Example(); Thread t2 = new TheThread2(example); t1.start(); t2.start(); } } class Example { public synchronized void execute() { for(int i = 0; i < 20; i++) { try { Thread.sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("hello: " + i); } } public synchronized static void execute2() { for(int i = 0; i < 20; i++) { try { Thread.sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("world: " + i); } } } class TheThread extends Thread { private Example example; public TheThread(Example example) { this.example = example; } @Override public void run() { this.example.execute(); } } class TheThread2 extends Thread { private Example example; public TheThread2(Example example) { this.example = example; } @Override public void run() { this.example.execute2(); } }
· Java 中的每个对象都有一个锁(lock)或者叫做监视器(monitor),当访问某个对象的 synchronized 方法时,表示将该对象上锁,此时其他任何线程都无法再去访问该 synchronized 方法了,直到之前的那个线程执行方法完毕后(或者是抛出了异常),那么将该对象的锁释放掉,其他线程才有可能再去访问该 synchronized 方法。
· 如果一个对象有多个 synchronized 方法,某一时刻某个线程已经进入到了某个 synchronized 方法,那么在该方法没有执行完毕前,其他线程都是无法访问该对象的任何 synchronized 方法的。
·如果某个 synchronized 方法是 static 的,那么当线程访问该方法时,它锁的并不是 synchronized 方法所在的对象,而是 synchronized 方法所在的对象所对应的 Class 对象,因为java中无论一个类有多少个对象,这些对象都会对应唯一一个 Class 对象,因此当线程分别访问同一个类的两个对象的
static,synchronized 方法时,他们的执行顺序也是顺序的,也就是说一个线程先去执行方法,执行完毕后另一个线程才开始执行。
· synchronized 块,写法: synchronized(object){.....}。 表示线程在执行的时候会对 object 对象上锁。
·synchronized 方法是中粗粒度的并发控制,某一时刻,只能有一个线程执行该 synchronized 方法;synchronized块则是一种细粒度的并发控制,只会将块中的代码同步,位于方法内、synchronized 块之外的代码是可以被多个线程同时访问到的。
七、 线程间的相互作用
使用wait()、notify()
package com.bob.thread; public class Sample { private int number; public synchronized void increase() { // if (0 != number) //两个线程的时候用if没有问题,多了就有问题了 while (0 != number) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } number++; System.out.println(number); notify(); } public synchronized void decrease() { // if (0 == number) while (0 == number) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } number--; System.out.println(number); notify(); } }
package com.bob.thread; public class IncreaseThread extends Thread { private Sample sample; public IncreaseThread(Sample sample) { this.sample = sample; } @Override public void run() { for(int i = 0; i < 20; i++) { try { Thread.sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) { e.printStackTrace(); } sample.increase(); } } }
package com.bob.thread; public class DecreaseThread extends Thread { private Sample sample; public DecreaseThread(Sample sample) { this.sample = sample; } @Override public void run() { for(int i = 0; i < 20; i++) { try { Thread.sleep((long)(Math.random() * 1000)); } catch (InterruptedException e) { e.printStackTrace(); } sample.decrease(); } } }
package com.bob.thread; public class MainTest { public static void main(String[] args) { Sample sample = new Sample(); Thread t1 = new IncreaseThread(sample); Thread t2 = new DecreaseThread(sample); Thread t3 = new IncreaseThread(sample); Thread t4 = new DecreaseThread(sample); Thread t5 = new IncreaseThread(sample); Thread t6 = new DecreaseThread(sample); t1.start(); t2.start(); t3.start(); t4.start(); t5.start(); t6.start(); } }
· wait 与 notify 方法都是定义在 Object 类中,而且是 final 的,因此会被所有的 java 类所继承并且无法重写。这两个方法要求在调用时线程应该已经获得了对象的锁,因此对这两个方法的调用需要放在 synchronized 方法或块当中。当线程执行了 wait 方法时,它会释放掉对象的锁。
·wait 和 sleep 区别:另一个会导致线程暂停的方法就是 Thread 类的 sleep 方法,它会导致线程睡眠指定的毫秒数,但线程在睡眠过程中是不会释放掉对象的锁的。
相关文章推荐
- Java基础知识强化之多线程笔记05:Java中继承thread类 与 实现Runnable接口的区别
- Java学习笔记67. 创建多线程的方法 -- 通过继承thread类创建多线程
- java笔记—多线程编程 Thread
- Java多线程高并发学习笔记(一)——Thread&Runnable
- java多线程总结笔记1——Runnable和Thread
- Java学习笔记44(多线程一:Thread类)
- java笔记(五):多线程--Thread和Runnable
- 学习java多线程的笔记1--Thread(Runnable t)与重写run()方法等
- java 多线程并行计算之矩阵乘法继承Thread类实现(星星笔记)
- JAVA学习笔记之多线程
- java笔记8多线程
- corejava笔记1 多线程
- JAVA多线程学习笔记
- Java 多线程编程 学习笔记
- java学习笔记-java.lang.Thread
- .net多线程学习笔记 2 thread生命周期
- java socket和多线程(Thread)实例
- JAVA多线程 -- 留个笔记
- Java 多线程的Thread类和Runnable接口
- Java 多线程的Thread类和Runnable接口