[线程的并发与并行]
在单CPU系统中,系统调度在某一时刻只能让一个线程运行,虽然这种调试机制有多种形式(大多数是时间片轮巡为主),但无论如何,要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统中,可以让两个以上的线程同时运行,这种可以同时让两个以上线程同时运行的方式叫做并行(parallel)。
[ 并发:(1)在CUP空闲的时候可以对某一个线程时行调度,运行
(2)当某一线程运行一部分后需要另一线程产生的结果,才能运行下去。
并行: 在多cup的情况下可以同时运行两个以上的线程的进候属于并行, 这些线程这间是独立的,并没有太多 的联系
]
[JAVA线程对象]
在JAVA中,要开始一个线程,有两种方式。
一 是直接调用Thread实例的start()方法
二 将Runable实例传给一个Thread实例然后调用它的start()方法。
生成一个线程的实例,并不代表启动了线程。而启动线程是说在某个线程对象上启动了该实例对应的线程,当该线程结束后,并不会就立即消失。
示例一 :
public class SongThread extends Thread{
private int x=0;
public void run(){
for(int i=0;i<100;i++){
try {
Thread.sleep(1);
System.out.println(x++);
} catch (InterruptedException e) {
System.out.println(x++);
}
}
}
//测试1:单独调动已经实例化的线程类。线程类SongThread并不是main中的主线程。所以会先运行system.out.println();
public static void main(String[] args){
SongThread songthread=new SongThread();
songthread.start();
System.out.println("songqiu");
}
//测试2:把SongThread类加入main主线程
// public static void main(String[] args){
// System.out.println("songqiu");
// SongThread songthread=new SongThread();
// songthread.start();
// try {
// songthread.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println("songqiu");
// }
//测试3:当线程类SongThread调用过一次start()方法后,然后在去调用一次start(),这个时候去发生异常
//异常产生的原因是:继承Thread抽象类的类,启动线程类只能产生一个线程,当这个线程类调用start()方法后,会自动结束线程的生命周期
// public static void main(String[] args){
// SongThread songthread =new SongThread();
//
// System.out.println("第一次调用线程songthread : 开始......");
// songthread.start();
// try {
// songthread.join();
// Thread.sleep(5000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println("第一次调用线程songthread结束!");
// System.out.println("=================");
//
// System.out.println("第二次调用线程songthread : 开始......");
// try{
// songthread.start();
// System.out.println("第二次调用线程songthread结束!");
// }catch(IllegalThreadStateException e){
// System.out.println("第二次调用线程时发生异常!");
// }
// }
}
示例二:
public class SongRunnable implements Runnable{
private int x=0;
public void run() {
for(int i=0;i<100;i++){
try {
Thread.sleep(1);
System.out.println(x++);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//测试1:此类继承了接口Runnable,然后去实现run()方法,但此类要产生线程的话必须用Thread抽象类去包装
//此方法任可以加入main主线程
public static void main(String[] args){
new Thread(new SongRunnable()).start();
}
//测试2:产生多个线程,线程可以利用存贮区域里的变最
// public static void main(String[] args){
// SongThread songthread=new SongThread();
//
// for(int i=0;i<2;i++){
//
// System.out.println("第"+(i+1)+"调用线程,开始...");
// Thread threadRunnable =new Thread(songthread);
// threadRunnable.start();
// try {
// threadRunnable.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//
// System.out.println("第"+(i+1)+"调用线程结束。");
// System.out.println("==============================");
// }
// }
}
在单CPU系统中,系统调度在某一时刻只能让一个线程运行,虽然这种调试机制有多种形式(大多数是时间片轮巡为主),但无论如何,要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统中,可以让两个以上的线程同时运行,这种可以同时让两个以上线程同时运行的方式叫做并行(parallel)。
[ 并发:(1)在CUP空闲的时候可以对某一个线程时行调度,运行
(2)当某一线程运行一部分后需要另一线程产生的结果,才能运行下去。
并行: 在多cup的情况下可以同时运行两个以上的线程的进候属于并行, 这些线程这间是独立的,并没有太多 的联系
]
[JAVA线程对象]
在JAVA中,要开始一个线程,有两种方式。
一 是直接调用Thread实例的start()方法
二 将Runable实例传给一个Thread实例然后调用它的start()方法。
生成一个线程的实例,并不代表启动了线程。而启动线程是说在某个线程对象上启动了该实例对应的线程,当该线程结束后,并不会就立即消失。
示例一 :
public class SongThread extends Thread{
private int x=0;
public void run(){
for(int i=0;i<100;i++){
try {
Thread.sleep(1);
System.out.println(x++);
} catch (InterruptedException e) {
System.out.println(x++);
}
}
}
//测试1:单独调动已经实例化的线程类。线程类SongThread并不是main中的主线程。所以会先运行system.out.println();
public static void main(String[] args){
SongThread songthread=new SongThread();
songthread.start();
System.out.println("songqiu");
}
//测试2:把SongThread类加入main主线程
// public static void main(String[] args){
// System.out.println("songqiu");
// SongThread songthread=new SongThread();
// songthread.start();
// try {
// songthread.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println("songqiu");
// }
//测试3:当线程类SongThread调用过一次start()方法后,然后在去调用一次start(),这个时候去发生异常
//异常产生的原因是:继承Thread抽象类的类,启动线程类只能产生一个线程,当这个线程类调用start()方法后,会自动结束线程的生命周期
// public static void main(String[] args){
// SongThread songthread =new SongThread();
//
// System.out.println("第一次调用线程songthread : 开始......");
// songthread.start();
// try {
// songthread.join();
// Thread.sleep(5000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println("第一次调用线程songthread结束!");
// System.out.println("=================");
//
// System.out.println("第二次调用线程songthread : 开始......");
// try{
// songthread.start();
// System.out.println("第二次调用线程songthread结束!");
// }catch(IllegalThreadStateException e){
// System.out.println("第二次调用线程时发生异常!");
// }
// }
}
示例二:
public class SongRunnable implements Runnable{
private int x=0;
public void run() {
for(int i=0;i<100;i++){
try {
Thread.sleep(1);
System.out.println(x++);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//测试1:此类继承了接口Runnable,然后去实现run()方法,但此类要产生线程的话必须用Thread抽象类去包装
//此方法任可以加入main主线程
public static void main(String[] args){
new Thread(new SongRunnable()).start();
}
//测试2:产生多个线程,线程可以利用存贮区域里的变最
// public static void main(String[] args){
// SongThread songthread=new SongThread();
//
// for(int i=0;i<2;i++){
//
// System.out.println("第"+(i+1)+"调用线程,开始...");
// Thread threadRunnable =new Thread(songthread);
// threadRunnable.start();
// try {
// threadRunnable.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//
// System.out.println("第"+(i+1)+"调用线程结束。");
// System.out.println("==============================");
// }
// }
}