Java——多线程安全问题
2014-07-07 09:51
411 查看
静态代码块中没有this[/u]
/*
* 线程安全问题产生的原因：
* 1.多个线程操作共享的数据
* 2.操作共享数据的线程代码有多条
*
* 当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了云轩。就会导致线程安全问题的产生。
* 解决思路：
* 就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算的。
* 必须要当前线程把这些代码都执行完成后，其他线程才可以参与运算。
*
* 在java中，用同步代码块就可以解决这个问题。
同步函数使用的锁是this
* 同步代码块的格式：
* synchronized（对象）
* {
*
需要被同步的 代码块；
* }
同步的好处：解决了线程的安全问题。
* 同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。
同步函数使用的锁是this；
同步函数和同步代码块的区别：
同步函数的锁是固有的的this。
同步代码块的锁是任意的对象。
建议使用 同步代码块。
*/
class TicketTest implements Runnable
{
private int num = 100;
private Object obj = new Object();
@Override
public void run()
{
// TODO Auto-generated method stub
while(true)
{
synchronized(obj)
{
if(num>0)
{
System.out.println(Thread.currentThread().getName()+"------------"+num--);
}
else
break;
}
}
}
}
public class Ticket
{
public static void main(String[] args)
{
//创建一个线程任务对象
TicketTest t = new TicketTest();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
l
/*
* 建立一个线程任务：
* 目的是 向银行 每次存款 100， 存3次
同步函数使用的锁是this
*/
class Bkk implements Runnable
{
private Bank b = new Bank();
@Override
public void run()
{
// TODO Auto-generated method stub
for(int i=0; i<3; i++)
{
b.add(100);
}
}
}
class Bank
{
private int sum;
同步函数使用的锁是this
public synchronized void add(int num)//同步函数********************
{
sum += num;
System.out.println(sum);
}
}
================================================================================
死锁问题——
public class LockTest
{
public static void main(String[] args)
{
// TODO Auto-generated method stub
RenWu a = new RenWu(true);
RenWu b = new RenWu(false);
Thread t1 = new Thread(a);
Thread t2 = new Thread(b);
t1.start();
t2.start();
}
}
//任务对象
class RenWu implements Runnable
{
private Boolean flag;//设定俩中情况
RenWu(Boolean flag)
{
this.flag = flag;
}
@Override
public void run()
{
// TODO Auto-generated method stub
if(flag)//让第一种情况去用第一把锁
{
synchronized (MyLock.Locka)
{
System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Locka);
synchronized (MyLock.Lockb)//然后想用另外一把锁 这时发现 另外这把锁 有可能就被 另一个任务线程使用着
{
System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Lockb);
}
}
}
else//让第二种情况去使用 第二把锁
{
synchronized (MyLock.Lockb)
{
System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Lockb);
synchronized (MyLock.Locka)//然后想用另外一把锁 这时发现 另外这把锁 有可能就被 另一个任务线程使用着
{
System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Locka);
}
}
}
}
}
//只有俩把锁 主要有其中一把锁 被锁上了 另外想用这吧锁的 这能等正在用的这把锁被打开后 才能使用
class MyLock
{
final static Object Locka = new Object();
final static Object Lockb = new Object();
}
l
静态代码块中没有this[/u]
/*
* 线程安全问题产生的原因：
* 1.多个线程操作共享的数据
* 2.操作共享数据的线程代码有多条
*
* 当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了云轩。就会导致线程安全问题的产生。
* 解决思路：
* 就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算的。
* 必须要当前线程把这些代码都执行完成后，其他线程才可以参与运算。
*
* 在java中，用同步代码块就可以解决这个问题。
同步函数使用的锁是this
* 同步代码块的格式：
* synchronized（对象）
* {
*
需要被同步的 代码块；
* }
同步的好处：解决了线程的安全问题。
* 同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。
同步函数使用的锁是this；
同步函数和同步代码块的区别：
同步函数的锁是固有的的this。
同步代码块的锁是任意的对象。
建议使用 同步代码块。
*/
class TicketTest implements Runnable
{
private int num = 100;
private Object obj = new Object();
@Override
public void run()
{
// TODO Auto-generated method stub
while(true)
{
synchronized(obj)
{
if(num>0)
{
System.out.println(Thread.currentThread().getName()+"------------"+num--);
}
else
break;
}
}
}
}
public class Ticket
{
public static void main(String[] args)
{
//创建一个线程任务对象
TicketTest t = new TicketTest();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
l
/*
* 建立一个线程任务：
* 目的是 向银行 每次存款 100， 存3次
同步函数使用的锁是this
*/
class Bkk implements Runnable
{
private Bank b = new Bank();
@Override
public void run()
{
// TODO Auto-generated method stub
for(int i=0; i<3; i++)
{
b.add(100);
}
}
}
class Bank
{
private int sum;
同步函数使用的锁是this
public synchronized void add(int num)//同步函数********************
{
sum += num;
System.out.println(sum);
}
}
================================================================================
死锁问题——
public class LockTest
{
public static void main(String[] args)
{
// TODO Auto-generated method stub
RenWu a = new RenWu(true);
RenWu b = new RenWu(false);
Thread t1 = new Thread(a);
Thread t2 = new Thread(b);
t1.start();
t2.start();
}
}
//任务对象
class RenWu implements Runnable
{
private Boolean flag;//设定俩中情况
RenWu(Boolean flag)
{
this.flag = flag;
}
@Override
public void run()
{
// TODO Auto-generated method stub
if(flag)//让第一种情况去用第一把锁
{
synchronized (MyLock.Locka)
{
System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Locka);
synchronized (MyLock.Lockb)//然后想用另外一把锁 这时发现 另外这把锁 有可能就被 另一个任务线程使用着
{
System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Lockb);
}
}
}
else//让第二种情况去使用 第二把锁
{
synchronized (MyLock.Lockb)
{
System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Lockb);
synchronized (MyLock.Locka)//然后想用另外一把锁 这时发现 另外这把锁 有可能就被 另一个任务线程使用着
{
System.out.println(Thread.currentThread().getName()+".........."+ MyLock.Locka);
}
}
}
}
}
//只有俩把锁 主要有其中一把锁 被锁上了 另外想用这吧锁的 这能等正在用的这把锁被打开后 才能使用
class MyLock
{
final static Object Locka = new Object();
final static Object Lockb = new Object();
}
l
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 黑马程序员_java的多线程（对第十一课创建多线程及多线程安全问题总结）
- 《黑马程序员》java笔记->多线程安全问题
- java基础知识回顾之java Thread类学习（四）--java多线程安全问题（锁）
- java 学习-----多线程的安全问题
- 黑马程序员：Java基础——多线程之安全问题与同步
- Java多线程技术初识——4. 多线程安全问题的解决
- 黑马程序员--Java 多线程的安全问题
- java基础知识回顾之java Thread类学习（五）--java多线程安全问题（锁）同步的前提
- Java基础-多线程-②多线程安全问题
- java多线程安全问题
- Java笔记3 多线程<1>线程概述、多线程的创建、多线程的安全问题、静态同步函数的锁、死锁
- 【黑马程序员】Java基础05：多线程与其安全问题
- 静态变量、实例变量、局部变量在多线程环境下的线程安全问题 java 多线程
- java基础知识回顾之java Thread类学习（七）--java多线程安全问题（死锁）
- Java 学习笔记16：用ThreadLocal解决多线程安全问题
- 黑马程序员——java中关于同步函数（或同步代码块）解决多线程安全问题的加锁
- Java基础——多线程的安全问题
- java 多线程（线程间通信-解决安全问题)
- 黑马程序员——JAVA基础之多线程的安全问题
- Java Tread多线程（2）多线程安全问题