Java多线程线程、同步代码块、同步函数、死锁
2015-11-15 21:33
567 查看
1.线程
是"进程"中某个单一顺序的控制流。也被称为轻量进程（lightweight processes）。计算机科学术语，指运行中的程序的调度单位。
一个进程必须至少有一个线程,通常称为主线程。
2.线程调度
计算机通常只有一个CPU,在任意时刻只能执行一条机器指令,每个线程只有获得CPU的使用权才能执行指令.所谓多线程的并发运行,其实是指从宏观上看,各个线程轮流获得CPU的使用权,分别执行各自的任务.在运行池中,会有多个处于就绪状态的线程在等待CPU
JAVA虚拟机的一项任务就是负责线程的调度,线程调度是指按照特定机制为多个线程分配CPU的使用权.
Windows的调度是以线程为粒度调度的。调度的决策被严格限制在以线程为基础，并不考虑这个线程属于哪一个进程。当考虑到进程并不运行，而仅为其线程提供资源和运行的上下文环境时，这种方法就有意义了，例如，进程A有10个可运行的线程，进程B有2个可运行的线程，而且这12个线程的优先级别相同，那么，每一个线程将会使用1/12的CPU时间，而不是将CPU 50%的时间分配给进程A，50%
的时间分配给进程B。
有两种调度模型：分时调度模型和抢占式调度模型。
分时调度模型是指让所有的线程轮流获得cpu的使用权,并且平均分配每个线程占用的CPU的时间片这个也比较好理解。
java虚拟机采用抢占式调度模型，是指优先让可运行池中优先级高的线程占用CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用CPU。处于运行状态的线程会一直运行，直至它不得不放弃CPU。
一个线程会因为以下原因而放弃CPU：
1 java虚拟机让当前线程暂时放弃CPU，转到就绪状态，使其它线程获得运行机会。
2 当前线程因为某些原因而进入阻塞状态
3 线程结束运行
需要注意的是，线程的调度不是跨平台的，它 不仅仅取决于java虚拟机，还依赖于操作系统。在某些操作系统中，只要运行中的线程没有遇到阻塞，就不会放弃CPU；在某些操作系统中，即使线程没有遇到阻塞，也会运行一段时间后放弃CPU，给其它线程运行的机会。
java的线程调度是不分时的，同时启动多个线程后，不能保证各个线程轮流获得均等的CPU时间片。
如果希望明确地让一个线程给另外一个线程运行的机会，可以采取以下办法之一。
调整各个线程的优先级
让处于运行状态的线程调用Thread.sleep()方法
让处于运行状态的线程调用Thread.yield()方法
让处于运行状态的线程调用另一个线程的join()方法
3.例子
[java] view
plaincopy
public class Demo {
public static void main(String[] args) {
new Test();
new Test();
new Test();
new Test();
System.gc(); //调用gc
System.out.println("hello world");
}
}
class Test
{
public void finalize(){
System.out.println("test clear");
}
}
/**
反复运行并观察输出,其结果是不确定的。因为main主线程、垃圾回收线程，它们线程优先级相同，随机占用cpu
*/
4.创建线程方式一
1)定义类继承Thread类，覆盖run方法(线程所要执行的代码)，将业务代码写在run方法中。
2)通过实例化，来创建线程，通过start启动线程，调用线程任务run方法
3)run和start区别
run()方法:在本线程内调用该Runnable对象的run()方法，可以重复多次调用；
start()方法:启动一个线程，调用该Runnable对象的run()方法，不能多次启动一个线程；
4)getName()与Thread.currentThread().getName()
每个继承Thread类的子类，在创建时都有自己的线程名称，都有getName()方法;
run函数中，getName()和Thread.currentThread().getName()是有区别的，前者是线程对象的名称，后者是当前运行线程的名称
5)例子
example01
[java] view
plaincopy
public class Demo2 {
public static void main(String[] args) {
Test2 t1=new Test2();
Test2 t2=new Test2();
//t1.run();
//t2.run();
t1.start();
t2.start();
System.out.println(Thread.currentThread().getName());
}
}
class Test2 extends Thread
{
public void run(){
for(int i=1;i<=10;i++){
System.out.println(Thread.currentThread().getName());
//System.out.println(getName()); //run或start结果一样，对象名
}
}
}
example02
[java] view
plaincopy
public class Demo1 {
public static void main(String[] args) {
Ticket t1=new Ticket();
Ticket t2=new Ticket();
Ticket t3=new Ticket();
Ticket t4=new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket extends Thread
{
private static int num=10;
public void run(){
while(num>0){
System.out.println(getName()+":"+--num);
}
}
}
/**
输出结果可能不是有序的，原因多个线程同时执行，某个线程可能--num后，将值传给println方法，
执行println方法时，还没有来得及打印，但失去执行权，后来某个时刻又获取到执行权
*/
6)每条线程有自己的栈空间，意味着每个线程都有自己的局部变量
5.线程的五种状态
创建、运行、消亡(run方法结束或stop())、睡眠(sleep)、等待(wait方法，对应notify唤醒方法)
1)cpu的执行资格：可以被cpu处理的线程，在处理队列中
2)cpu的执行权：正在被cpu处理
3)睡眠和等待，设置线程执行资格与执行权
4)运行：既具备执行资格、又有执行权
5)cpu处理某线程时，该线程具备执行资格，执行权，其它线程不具备执行权，但具备执行资格，处于临时阻塞状态，等待执行权
6)睡眠和等待，都不具备
6.创建线程方式二
1)定义类实现Runnable接口，覆盖run方法，将线程的任务代码封装到run中
2)通过Thread创建线程对象，并将Runnable子类对象作为构造函数的参数传递
7.两种创建对比
继承Thread与实现Runnable接口，前者具备线程所有功能，强调is-a的关系，后者仅仅提供线程任务功能，强调has-a
Runnable好处：避免单继承的局限性，将任务从线程中的子类中分离，将任务封装成对象。
8.多线程安全问题
多个线程操作(修改)共享的数据，可能存在安全问题。
9.同步代码块
synchronized(对象)
{
}
好处：解决线程的安全问题
弊端：都会判断同步锁，降低效率
使用前提：多个线程使用同一个锁
===============================分割线==========================
1.同步函数
[java] view
plaincopy
class Bank implements Runnable {
private int sum;
private Object obj = new Object();
public void add(int num) {
synchronized (obj) {
sum += num;
System.out.println("sum=" + sum);
}
}
public void run() {
for (int i = 0; i <= 3; i++) {
add(100);
}
}
}
/*add函数中存在同步代码块,可直接改写为同步函数,Object对象可以删除*/
[java] view
plaincopy
public synchronized void add(int num) {
sum += num;
System.out.println("sum=" + sum);
}
2.同步函数设置在run函数上，会被某个线程一直占用，直到它执行结束，其他线程才能得到处理权
3.同步代码块和同步函数区别
同步代码块的锁是任意的对象，同步函数的锁是this
4.静态同步函数的锁
使用的锁是该方法所在类的字节码文件对象，类名.class或this.getClass()
(字节码文件对象：JVM在加载某个.class文件之后得到的一段字节？？还是就是.class本身？)
5.死锁
是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
简单解释：flag判断，会让两个线程进入不同的语句块，线程1有拿到了A锁，线程2拿到了B锁。当他们进入各自语句块的时候，均拿到了第一层的锁，没拿到第二层的锁，都变为挂起状态，此时他们各自占有资源都没有释放，都需要对方释放资源才能继续，因此死锁
简单演示
[java] view
plaincopy
package lock;
public class Demo {
public static void main(String[] args) {
LockDemo d1=new LockDemo(true);
LockDemo d2=new LockDemo(false);
Thread t1=new Thread(d1);
Thread t2=new Thread(d2);
t1.start();
t2.start();
}
}
class LockDemo implements Runnable
{
private boolean flag;
LockDemo(boolean flag){
this.flag=flag;
}
public void run(){
if(flag)
{
synchronized(Lock.lockA)
{
System.out.println("true lockA");
synchronized(Lock.lockB)
{
System.out.println("true lockB");
}
}
System.out.println("true over");
}
else
{
synchronized(Lock.lockB)
{
System.out.println("false lockB");
synchronized(Lock.lockA)
{
System.out.println("false lockA");
}
}
System.out.println("false over");
}
}
}
class Lock
{
public static final Object lockA=new Object();
public static final Object lockB=new Object();
}
是"进程"中某个单一顺序的控制流。也被称为轻量进程（lightweight processes）。计算机科学术语，指运行中的程序的调度单位。
一个进程必须至少有一个线程,通常称为主线程。
2.线程调度
计算机通常只有一个CPU,在任意时刻只能执行一条机器指令,每个线程只有获得CPU的使用权才能执行指令.所谓多线程的并发运行,其实是指从宏观上看,各个线程轮流获得CPU的使用权,分别执行各自的任务.在运行池中,会有多个处于就绪状态的线程在等待CPU
JAVA虚拟机的一项任务就是负责线程的调度,线程调度是指按照特定机制为多个线程分配CPU的使用权.
Windows的调度是以线程为粒度调度的。调度的决策被严格限制在以线程为基础，并不考虑这个线程属于哪一个进程。当考虑到进程并不运行，而仅为其线程提供资源和运行的上下文环境时，这种方法就有意义了，例如，进程A有10个可运行的线程，进程B有2个可运行的线程，而且这12个线程的优先级别相同，那么，每一个线程将会使用1/12的CPU时间，而不是将CPU 50%的时间分配给进程A，50%
的时间分配给进程B。
有两种调度模型：分时调度模型和抢占式调度模型。
分时调度模型是指让所有的线程轮流获得cpu的使用权,并且平均分配每个线程占用的CPU的时间片这个也比较好理解。
java虚拟机采用抢占式调度模型，是指优先让可运行池中优先级高的线程占用CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用CPU。处于运行状态的线程会一直运行，直至它不得不放弃CPU。
一个线程会因为以下原因而放弃CPU：
1 java虚拟机让当前线程暂时放弃CPU，转到就绪状态，使其它线程获得运行机会。
2 当前线程因为某些原因而进入阻塞状态
3 线程结束运行
需要注意的是，线程的调度不是跨平台的，它 不仅仅取决于java虚拟机，还依赖于操作系统。在某些操作系统中，只要运行中的线程没有遇到阻塞，就不会放弃CPU；在某些操作系统中，即使线程没有遇到阻塞，也会运行一段时间后放弃CPU，给其它线程运行的机会。
java的线程调度是不分时的，同时启动多个线程后，不能保证各个线程轮流获得均等的CPU时间片。
如果希望明确地让一个线程给另外一个线程运行的机会，可以采取以下办法之一。
调整各个线程的优先级
让处于运行状态的线程调用Thread.sleep()方法
让处于运行状态的线程调用Thread.yield()方法
让处于运行状态的线程调用另一个线程的join()方法
3.例子
[java] view
plaincopy
public class Demo {
public static void main(String[] args) {
new Test();
new Test();
new Test();
new Test();
System.gc(); //调用gc
System.out.println("hello world");
}
}
class Test
{
public void finalize(){
System.out.println("test clear");
}
}
/**
反复运行并观察输出,其结果是不确定的。因为main主线程、垃圾回收线程，它们线程优先级相同，随机占用cpu
*/
4.创建线程方式一
1)定义类继承Thread类，覆盖run方法(线程所要执行的代码)，将业务代码写在run方法中。
2)通过实例化，来创建线程，通过start启动线程，调用线程任务run方法
3)run和start区别
run()方法:在本线程内调用该Runnable对象的run()方法，可以重复多次调用；
start()方法:启动一个线程，调用该Runnable对象的run()方法，不能多次启动一个线程；
4)getName()与Thread.currentThread().getName()
每个继承Thread类的子类，在创建时都有自己的线程名称，都有getName()方法;
run函数中，getName()和Thread.currentThread().getName()是有区别的，前者是线程对象的名称，后者是当前运行线程的名称
5)例子
example01
[java] view
plaincopy
public class Demo2 {
public static void main(String[] args) {
Test2 t1=new Test2();
Test2 t2=new Test2();
//t1.run();
//t2.run();
t1.start();
t2.start();
System.out.println(Thread.currentThread().getName());
}
}
class Test2 extends Thread
{
public void run(){
for(int i=1;i<=10;i++){
System.out.println(Thread.currentThread().getName());
//System.out.println(getName()); //run或start结果一样，对象名
}
}
}
example02
[java] view
plaincopy
public class Demo1 {
public static void main(String[] args) {
Ticket t1=new Ticket();
Ticket t2=new Ticket();
Ticket t3=new Ticket();
Ticket t4=new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket extends Thread
{
private static int num=10;
public void run(){
while(num>0){
System.out.println(getName()+":"+--num);
}
}
}
/**
输出结果可能不是有序的，原因多个线程同时执行，某个线程可能--num后，将值传给println方法，
执行println方法时，还没有来得及打印，但失去执行权，后来某个时刻又获取到执行权
*/
6)每条线程有自己的栈空间，意味着每个线程都有自己的局部变量
5.线程的五种状态
创建、运行、消亡(run方法结束或stop())、睡眠(sleep)、等待(wait方法，对应notify唤醒方法)
1)cpu的执行资格：可以被cpu处理的线程，在处理队列中
2)cpu的执行权：正在被cpu处理
3)睡眠和等待，设置线程执行资格与执行权
4)运行：既具备执行资格、又有执行权
5)cpu处理某线程时，该线程具备执行资格，执行权，其它线程不具备执行权，但具备执行资格，处于临时阻塞状态，等待执行权
6)睡眠和等待，都不具备
6.创建线程方式二
1)定义类实现Runnable接口，覆盖run方法，将线程的任务代码封装到run中
2)通过Thread创建线程对象，并将Runnable子类对象作为构造函数的参数传递
7.两种创建对比
继承Thread与实现Runnable接口，前者具备线程所有功能，强调is-a的关系，后者仅仅提供线程任务功能，强调has-a
Runnable好处：避免单继承的局限性，将任务从线程中的子类中分离，将任务封装成对象。
8.多线程安全问题
多个线程操作(修改)共享的数据，可能存在安全问题。
9.同步代码块
synchronized(对象)
{
}
好处：解决线程的安全问题
弊端：都会判断同步锁，降低效率
使用前提：多个线程使用同一个锁
===============================分割线==========================
1.同步函数
[java] view
plaincopy
class Bank implements Runnable {
private int sum;
private Object obj = new Object();
public void add(int num) {
synchronized (obj) {
sum += num;
System.out.println("sum=" + sum);
}
}
public void run() {
for (int i = 0; i <= 3; i++) {
add(100);
}
}
}
/*add函数中存在同步代码块,可直接改写为同步函数,Object对象可以删除*/
[java] view
plaincopy
public synchronized void add(int num) {
sum += num;
System.out.println("sum=" + sum);
}
2.同步函数设置在run函数上，会被某个线程一直占用，直到它执行结束，其他线程才能得到处理权
3.同步代码块和同步函数区别
同步代码块的锁是任意的对象，同步函数的锁是this
4.静态同步函数的锁
使用的锁是该方法所在类的字节码文件对象，类名.class或this.getClass()
(字节码文件对象：JVM在加载某个.class文件之后得到的一段字节？？还是就是.class本身？)
5.死锁
是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
简单解释：flag判断，会让两个线程进入不同的语句块，线程1有拿到了A锁，线程2拿到了B锁。当他们进入各自语句块的时候，均拿到了第一层的锁，没拿到第二层的锁，都变为挂起状态，此时他们各自占有资源都没有释放，都需要对方释放资源才能继续，因此死锁
简单演示
[java] view
plaincopy
package lock;
public class Demo {
public static void main(String[] args) {
LockDemo d1=new LockDemo(true);
LockDemo d2=new LockDemo(false);
Thread t1=new Thread(d1);
Thread t2=new Thread(d2);
t1.start();
t2.start();
}
}
class LockDemo implements Runnable
{
private boolean flag;
LockDemo(boolean flag){
this.flag=flag;
}
public void run(){
if(flag)
{
synchronized(Lock.lockA)
{
System.out.println("true lockA");
synchronized(Lock.lockB)
{
System.out.println("true lockB");
}
}
System.out.println("true over");
}
else
{
synchronized(Lock.lockB)
{
System.out.println("false lockB");
synchronized(Lock.lockA)
{
System.out.println("false lockA");
}
}
System.out.println("false over");
}
}
}
class Lock
{
public static final Object lockA=new Object();
public static final Object lockB=new Object();
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- javaWeb常见异常的解决方法
- java 对象序列化使用
- java中内部类访问局部变量的时候，为什么变量必须加上final修饰
- java web开发 高并发处理
- Java设计模式单例模式记录
- Java判断两个路径对应的文件是否相同
- Java内部类
- java中怎么进行字符串替换？
- java中读写文件到手机SD卡
- java IO之Print、Scanner和对象序列化
- iOS 开发学习－类的创建与实现,与java语言的对比
- Java实现不规则窗体
- 一个简单的Java反编译实例
- 配置springMVC时出现的问题
- JAVA方法 字符串与unicode的相互转换
- struts2学习笔记
- Java中的分代垃圾回收策略
- Java [leetcode 36]Valid Sudoku
- 【Java】Java运行cmd命令直接导出.sql文件
- 【Java集合源码剖析】ArrayList源码剖析