</pre><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px"></span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px">1.进程与线程<span style="white-space:pre"> </span><span style="white-space:pre"> </span></span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px"><span style="white-space:pre"> </span>几乎所有的操作系统都支持同时运行多个任务,一个任务通常就是一个程序,每个运行中的程序就是一个进程。当一个程序运行时,内部可能包含了多个顺序执行流,每个顺序执行流就是一个线程。 </span></span></span></span><span style="white-space: pre;">几乎所有操作系统都支持进程的概念,所有运行中的任务通常对应一条进程(Process)。当一个程序进入内存运行,即变成一个进程。</span><span style="white-space: pre;"> </span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"> </span>进程是处于运行过程中的程序,并且具有一定独立功能,进程是系统进行资源分配和调度的一个独立单位。一般而言,进程包含如下三个特征:<span style="white-space:pre"> </span>1.独立性:进程是系统中独立存在的实体,它可以拥有自己独立的资源,每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间。<span style="white-space:pre"> </span>2.动态性:进程与程序的区别在于:程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各种不同的状态,这些概念在程序中都是不具备的。<span style="white-space:pre"> </span>3.并发性:多个进程可以在单个处理器上并发执行,多个进程之间不会互相影响。 <span style="white-space:pre"> </span>2.多线程<span style="white-space:pre"> </span>多线程则扩展了多进程的概念,使得同一个进行可以同时并发处理多个任务。<span style="white-space:pre"> </span>线程(Thread)也被称作轻量级进程(Ligheweight Process),线程是进程的执行单元。就象进程在操作系统中的地位一样,线程在程序中是独立的、并发的执行流。当进程被初始化后,主线程就被创建了。<span style="white-space:pre"> </span>对于绝大多数的应用程序来说,通常仅要求有一个主线程,但我们也可以在该进程内创建多条顺序执行流,这些顺序执行流就是线程,每条线程也是互相独立的。<span style="white-space:pre"> </span>线程是进程的组成部分,一个进程可以拥有多个线程,一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量,但不再拥有系统资源,它与父进程的其它线程共享该进程所拥有的全部资源。因为多个线程共享父进程里的全部资源,因此编程更加方便;但必须更加小心,我们必须确保线程不会妨碍同一进程里的其它线程。<span style="white-space:pre"> </span>线程可以完成一定的任务,可与其他线程共享父进程中的共享变量及部分环境、相互之间协同来完成进程所要完成的任务 .<span style="white-space:pre"> </span>一个Java应用程序至少有两个线程,一个是主线程负责main方法代码的执行,一个是垃圾回收器线程,负责了回收垃圾。<3.多线程的优势<span style="white-space:pre"> </span>进程间不能共享内存,但线程之间共享内存非常容易。系统创建进程需要为该进程重新分配系统资源,但创建线程则代价小得多,因此使用多线程来实现多任务并发比多进程的效率高。<span style="white-space:pre"> </span>Java语言内置的多线程功能支持,而不是单纯地作为底层操作系统的调度方式,从而简化了Java的多线程编程。4.如何创建线程 <span style="white-space:pre"> </span>1. 自定义一个类继承Thread类。<span style="white-space:pre"> </span>2. 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法<span style="white-space:pre"> </span>3. 创建Thread的子类对象,并且调用start方法开启线程 。<span style="white-space:pre"> </span>疑问: 重写run方法的目的是什么? <span style="white-space:pre"> </span>每个线程都有自己的任务代码,jvm创建的主线程的任务代码就是main方法中的所有代码, 自定义线程的任务代码就写在run方法中,自定义线程负责了run方法中代码。<span style="white-space:pre"> </span>注意:一个线程一旦开启,那么线程就会执行run方法中的代码,run方法千万不能直接调用,直接调用run方法就相当调用了一个普通的方法而已并没有开启新的线程。</span></span></span></div><div></div><div></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px"><span style="white-space:pre"></span></span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px"><span style="white-space:pre"> </span></span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"> </span>例如:</span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"> </span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"> </span></span></span><pre name="code" class="java">public class demo1 extends Thread {
//把自定义线程的任务代码写在run方法中。
public void run(){
for(int i = 0; i < 100; i++)
System.out.println("自定义线程:"+i);
}
public static void main(String[] args) {
//创建自定义线程对象
demo1 d = new demo1();
//调用start方法启动线程
d.start();
for(int i = 0; i < 100; i++){
System.out.println("main线程:"+i);
}
}
}
方式二:1. 自定义一个类实现Runnable接口。2. 实现Runnable接口 的run方法,把自定义线程的任务定义在run方法上。3. 创建Runnable实现类对象。4. 创建Thread类 的对象,并且把Runnable实现类的对象作为实参传递。5. 调用Thread对象的start方法开启一个线程。
注意:Runnable实现类的对象并 不是一个线程对象,只不过是实现了Runnable接口 的对象而已。 只有是Thread或者是Thread的子类才是线程 对象。
例如:
<span style="font-size:14px;"><span style="font-size:14px;">package uestc.Thread;
public class Demo2 implements Runnable { //自定义一个类实现Runnable接口
public void run(){ //实现Runnable接口的run方法,把自定义线程的任务定义在run方法上
for(int i = 0; i < 100; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
public static void main(String[] args) {
//创建Runnable实现类的对象
Demo2 d = new Demo2();
//创建Thread类的对象,把Runnable实现类对象作为实参传递。
Thread thread1 = new Thread(d,"线程1"); //Thread使用Target变量记录了d对象。
//调用thread对象的start方法开启线程。
thread1.start();
for(int i = 0 ; i < 100 ; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
/*
Thread类的run方法:
* @Override
public void run() {
if (target != null) {
target.run(); //就相当于Runnable实现类的对象的run方法作为了Thread对象的任务代码了。
}
}
*/</span></span>
5.两种线程方式的对比
1.采用实现Runnable接口方式的多线程:
线程类只是实现了Runnable接口,还可以可以继承其他类。
在这种方式下,可以多个线程共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,
从而可以将CPU,代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。
劣势是:编程稍稍复杂,如果需要访问当前线程,必须使用Thread.currentThread()方法。
2.采用继承Thread类方式的多线程:
劣势是:因为线程类已经继承了Thread类,所以不能再继承其他父类。
优势是:编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this即可获得当前线程 .
6.线程常用的方法
Thread(String name) 初始化线程的名字
setName(String name) 设置线程对象名
getName() 返回线程的名字
sleep() 线程睡眠指定的毫秒数。 静态的方法,哪个线程执行了sleep方法代码那么就是哪个线程睡眠。
currentThread() 返回当前的线程对象,该方法是一个静态的方法, 注意:哪个线程执行了currentThread()代码就返回哪个线程的对象。
getPriority() 返回当前线程对象的优先级 默认线程的优先级是5
setPriority(int newPriority) 设置线程的优先级 虽然设置了线程的优先级,但是具体的实现取决于底层的操作系统的实现(最大的优先级是10 ,最小的1 , 默认是5)。
7.线程安全问题
多条线程并发修改共享资源就容易引发线程安全问题。
解决方案:
线程安全问题的解决方案:sun提供了线程同步机制让我们解决这类问题的。
方法一:同步代码块
同步代码块的格式:
synchronized(锁对象){
需要被同步的代码...
}
同步代码块要注意事项:
1. 任意的一个对象都可以做为锁对象。
2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
3. 只有真正存在线程安全问题的时候才使用同步代码块,否则会降低效率的。
4. 多线程操作的锁对象必须是唯一共享的。否则无效。
例如:
<span style="font-size:14px;"><span style="font-size:14px;">package uestc.Thread;
//模拟售票中的线程安全问题的解决方案
class SaleTicket extends Thread{
static int num = 50; //票数 非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。
static Object o = new Object();
public SaleTicket(String name){
super(name);
}
public void run(){
while(true){
synchronized(o){
if(num > 0){
System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
num--;
}else{
System.out.println("售馨了...");
break;
}
}
}
}
}
public class Demo3 {
public static void main(String[] args) {
//创建三个线程对象,模拟三个窗口
SaleTicket thread1 = new SaleTicket("窗口1");
SaleTicket thread2 = new SaleTicket("窗口2");
SaleTicket thread3 = new SaleTicket("窗口3");
//开启售票
thread1.start();
thread2.start();
thread3.start();
}
}</span><span style="font-size:18px;">
</span></span>
方式二:同步函数 : 同步函数就是使用synchronized修饰一个函数。
同步函数要注意的事项 :
1. 如果是一个非静态的同步函数的锁 对象是this对象,如果是静态的同步函数的锁 对象是当前函数所属的类的字节码文件(class对象)。
2. 同步函数的锁对象是固定的,不能由你来指定 的。
推荐使用: 同步代码块。
原因:
1. 同步代码块的锁对象可以由我们随意指定,方便控制。同步函数的锁对象是固定 的,不能由我们来指定。
2. 同步代码块可以很方便控制需要被同步代码的范围,同步函数必须是整个函数的所有代码都被同步了。
8.死锁现象
java中同步机制解决了线程安全问题,但是也同时引发死锁现象。
当两个线程相互等待对方释放同步监视器时就会发生死锁,Java虚拟机没有监测、也没有采用措施来处理死锁情况,
所以多线程编程时应该采取措施避免死锁的出现。
一旦出现死锁,整个程序既不会发生任何异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续。
</pre><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px"></span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px">1.进程与线程<span style="white-space:pre"> </span><span style="white-space:pre"> </span></span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px"><span style="white-space:pre"> </span>几乎所有的操作系统都支持同时运行多个任务,一个任务通常就是一个程序,每个运行中的程序就是一个进程。当一个程序运行时,内部可能包含了多个顺序执行流,每个顺序执行流就是一个线程。 </span></span></span></span><span style="white-space: pre;">几乎所有操作系统都支持进程的概念,所有运行中的任务通常对应一条进程(Process)。当一个程序进入内存运行,即变成一个进程。</span><span style="white-space: pre;"> </span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"> </span>进程是处于运行过程中的程序,并且具有一定独立功能,进程是系统进行资源分配和调度的一个独立单位。一般而言,进程包含如下三个特征:<span style="white-space:pre"> </span>1.独立性:进程是系统中独立存在的实体,它可以拥有自己独立的资源,每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间。<span style="white-space:pre"> </span>2.动态性:进程与程序的区别在于:程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各种不同的状态,这些概念在程序中都是不具备的。<span style="white-space:pre"> </span>3.并发性:多个进程可以在单个处理器上并发执行,多个进程之间不会互相影响。 <span style="white-space:pre"> </span>2.多线程<span style="white-space:pre"> </span>多线程则扩展了多进程的概念,使得同一个进行可以同时并发处理多个任务。<span style="white-space:pre"> </span>线程(Thread)也被称作轻量级进程(Ligheweight Process),线程是进程的执行单元。就象进程在操作系统中的地位一样,线程在程序中是独立的、并发的执行流。当进程被初始化后,主线程就被创建了。<span style="white-space:pre"> </span>对于绝大多数的应用程序来说,通常仅要求有一个主线程,但我们也可以在该进程内创建多条顺序执行流,这些顺序执行流就是线程,每条线程也是互相独立的。<span style="white-space:pre"> </span>线程是进程的组成部分,一个进程可以拥有多个线程,一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量,但不再拥有系统资源,它与父进程的其它线程共享该进程所拥有的全部资源。因为多个线程共享父进程里的全部资源,因此编程更加方便;但必须更加小心,我们必须确保线程不会妨碍同一进程里的其它线程。<span style="white-space:pre"> </span>线程可以完成一定的任务,可与其他线程共享父进程中的共享变量及部分环境、相互之间协同来完成进程所要完成的任务 .<span style="white-space:pre"> </span>一个Java应用程序至少有两个线程,一个是主线程负责main方法代码的执行,一个是垃圾回收器线程,负责了回收垃圾。<3.多线程的优势<span style="white-space:pre"> </span>进程间不能共享内存,但线程之间共享内存非常容易。系统创建进程需要为该进程重新分配系统资源,但创建线程则代价小得多,因此使用多线程来实现多任务并发比多进程的效率高。<span style="white-space:pre"> </span>Java语言内置的多线程功能支持,而不是单纯地作为底层操作系统的调度方式,从而简化了Java的多线程编程。4.如何创建线程 <span style="white-space:pre"> </span>1. 自定义一个类继承Thread类。<span style="white-space:pre"> </span>2. 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法<span style="white-space:pre"> </span>3. 创建Thread的子类对象,并且调用start方法开启线程 。<span style="white-space:pre"> </span>疑问: 重写run方法的目的是什么? <span style="white-space:pre"> </span>每个线程都有自己的任务代码,jvm创建的主线程的任务代码就是main方法中的所有代码, 自定义线程的任务代码就写在run方法中,自定义线程负责了run方法中代码。<span style="white-space:pre"> </span>注意:一个线程一旦开启,那么线程就会执行run方法中的代码,run方法千万不能直接调用,直接调用run方法就相当调用了一个普通的方法而已并没有开启新的线程。</span></span></span></div><div></div><div></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px"><span style="white-space:pre"></span></span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="font-size:14px"><span style="white-space:pre"> </span></span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"> </span>例如:</span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"> </span></span></span></span></div><div><span style="white-space:pre"><span style="white-space:pre"><span style="white-space:pre"> </span></span></span><pre name="code" class="java">public class demo1 extends Thread {
//把自定义线程的任务代码写在run方法中。
public void run(){
for(int i = 0; i < 100; i++)
System.out.println("自定义线程:"+i);
}
public static void main(String[] args) {
//创建自定义线程对象
demo1 d = new demo1();
//调用start方法启动线程
d.start();
for(int i = 0; i < 100; i++){
System.out.println("main线程:"+i);
}
}
}
<span style="font-size:14px;"><span style="font-size:14px;">package uestc.Thread;
public class Demo2 implements Runnable { //自定义一个类实现Runnable接口
public void run(){ //实现Runnable接口的run方法,把自定义线程的任务定义在run方法上
for(int i = 0; i < 100; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
public static void main(String[] args) {
//创建Runnable实现类的对象
Demo2 d = new Demo2();
//创建Thread类的对象,把Runnable实现类对象作为实参传递。
Thread thread1 = new Thread(d,"线程1"); //Thread使用Target变量记录了d对象。
//调用thread对象的start方法开启线程。
thread1.start();
for(int i = 0 ; i < 100 ; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
/*
Thread类的run方法:
* @Override
public void run() {
if (target != null) {
target.run(); //就相当于Runnable实现类的对象的run方法作为了Thread对象的任务代码了。
}
}
*/</span></span>
线程类只是实现了Runnable接口,还可以可以继承其他类。
在这种方式下,可以多个线程共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,
劣势是:编程稍稍复杂,如果需要访问当前线程,必须使用Thread.currentThread()方法。
劣势是:因为线程类已经继承了Thread类,所以不能再继承其他父类。
优势是:编写简单,如果需要访问当前线程,无需使用Thread.currentThread()方法,直接使用this即可获得当前线程 .
setName(String name) 设置线程对象名
getName() 返回线程的名字
setPriority(int newPriority) 设置线程的优先级 虽然设置了线程的优先级,但是具体的实现取决于底层的操作系统的实现(最大的优先级是10 ,最小的1 , 默认是5)。
synchronized(锁对象){
需要被同步的代码...
}
1. 任意的一个对象都可以做为锁对象。
2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
3. 只有真正存在线程安全问题的时候才使用同步代码块,否则会降低效率的。
4. 多线程操作的锁对象必须是唯一共享的。否则无效。
<span style="font-size:14px;"><span style="font-size:14px;">package uestc.Thread;
//模拟售票中的线程安全问题的解决方案
class SaleTicket extends Thread{
static int num = 50; //票数 非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。
static Object o = new Object();
public SaleTicket(String name){
super(name);
}
public void run(){
while(true){
synchronized(o){
if(num > 0){
System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
num--;
}else{
System.out.println("售馨了...");
break;
}
}
}
}
}
public class Demo3 {
public static void main(String[] args) {
//创建三个线程对象,模拟三个窗口
SaleTicket thread1 = new SaleTicket("窗口1");
SaleTicket thread2 = new SaleTicket("窗口2");
SaleTicket thread3 = new SaleTicket("窗口3");
//开启售票
thread1.start();
thread2.start();
thread3.start();
}
}</span><span style="font-size:18px;">
</span></span>
同步函数要注意的事项 :
1. 如果是一个非静态的同步函数的锁 对象是this对象,如果是静态的同步函数的锁 对象是当前函数所属的类的字节码文件(class对象)。
2. 同步函数的锁对象是固定的,不能由你来指定 的。
原因:
1. 同步代码块的锁对象可以由我们随意指定,方便控制。同步函数的锁对象是固定 的,不能由我们来指定。
2. 同步代码块可以很方便控制需要被同步代码的范围,同步函数必须是整个函数的所有代码都被同步了。
当两个线程相互等待对方释放同步监视器时就会发生死锁,Java虚拟机没有监测、也没有采用措施来处理死锁情况,