Java线程同步锁
把synchronized当作函数修饰符时，示例代码如下:
Public synchronized void method(){
//….
}
这也就是同步方法，那这时synchronized锁定的是哪个对象呢？他锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，他们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却能够任意调用这个被加了synchronized关键字的方法。
如同这样
public void method()
{
synchronized (this) // (1)
{
//…..
}
}
此处的this指的是什么呢？他指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才能够调用P1的同步方法，而对P2而言，P1这个锁和他毫不相干，程式也可能在这种情形下摆脱同步机制的控制，造成数据混乱。具体使用像这样:
package com.java.Thread;
public class Mysynchronized {
/**
* @param args
*/
public static void main(String[] args) {
/*
* GetTickets gt1 = new GetTickets(); GetTickets gt2 = new GetTickets();
* GetTickets gt3 = new GetTickets(); gt1.setName("窗口一");
* gt2.setName("窗口二"); gt3.setName("窗口三"); gt1.start(); gt2.start();
* gt3.start();
*/
GetTickets2 gt = new GetTickets2();
Thread th1 = new Thread(gt, "窗口一");
Thread th2 = new Thread(gt, "窗口二");
Thread th3 = new Thread(gt, "窗口三");
th1.start();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
gt.flag = true;
th2.start();
th3.start();
}
}
class GetTickets2 implements Runnable {
private int tickets = 10;
boolean flag = false;
/* Object ob = new Object();*/
public void run() {
if (flag) {
for (int i = 0; i < 10; i++) {
//synchronized (ob) {//如果用ob就无法同步
synchronized (this) {
if (tickets > 0) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "卖出" + (tickets--) + "号票"+":同步代码块");
}
}
}
} else {
for (int i = 0; i < 10; i++) {
function();
}
}
}
public synchronized void function() {
if (tickets > 0) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出"
+ (tickets--) + "号票"+"：同步函数");
}
}
}
/*
* class GetTickets extends Thread{ //private static int tickets = 10; private
* int tickets = 10; public void run(){
*
* for (int i = 0; i < 10; i++) { if(tickets>0){
* System.out.println(Thread.currentThread().getName()+"卖出"+(tickets--)+"号票"); }
* } } }
*/
将synchronized作用于static 函数 同步的锁就是它自己本身的字节码，示例代码如下：
Class Foo
{
public synchronized static void method1() // 同步的static 函数
{
//….
}
public void method2()
{
synchronized(Foo.class) // class literal(类名称字面常量)
}
}
具体代码如下
package cn.java.thread;
/*
证明同步函数用的是this这把锁
*/
public class Tickets1 {
/**
* @param args
*/
public static void main(String[] args) {
/*
* GetTickets gt1 = new GetTickets(); GetTickets gt2 = new GetTickets();
* GetTickets gt3 = new GetTickets(); gt1.setName("窗口一");
* gt2.setName("窗口二"); gt3.setName("窗口三"); gt1.start(); gt2.start();
* gt3.start();
*/
GetTickets2 gt = new GetTickets2();
Thread th1 = new Thread(gt, "窗口一");
Thread th2 = new Thread(gt, "窗口二");
Thread th3 = new Thread(gt, "窗口三");
th1.start();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
gt.flag = true;
th2.start();
th3.start();
}
}
class GetTickets2 implements Runnable {
private static int tickets = 10;
boolean flag = false;
Object ob = new Object();
public void run() {
if (flag) {
for (int i = 0; i < 10; i++) {
//synchronized (this.getClass()) {
synchronized (GetTickets2.class) {
if (tickets > 0) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "卖出" + (tickets--) + "号票"+":同步代码块");
}
}
}
} else {
for (int i = 0; i < 10; i++) {
function();
}
}
}
public static synchronized void function() {
if (tickets > 0) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出"
+ (tickets--) + "号票"+"：同步函数");
}
}
}
/*
* class GetTickets extends Thread{ //private static int tickets = 10; private
* int tickets = 10; public void run(){
*
* for (int i = 0; i < 10; i++) { if(tickets>0){
* System.out.println(Thread.currentThread().getName()+"卖出"+(tickets--)+"号票"); }
* } } }
*/
然后嘞是 wait notify notifyall 这三个(两个)方法的 理解了 第一步 wait的作用是阻塞 notify的作用是唤醒
讲这个 要用到以前学到的生产者和消费者 对于他们的理解:
1.这些方法都存在与同步中
2;使用这些方法时必须要标记所属的同步锁
3:锁可以是任意对象,所以任意对象调用的方法一定定义在object类中 废话不多上代码:
这是同步代码块的
package com.java.Thread;
//定义一个rbq
class Production{
private String name;
private String country;
private boolean flag = true;
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
class Producer implements Runnable{
private Production p = null;
public Producer(Production p) {
this.p = p;
}
public void run(){
boolean b = true;
while(true){
synchronized (p) {
if(p.isFlag()){
//这个b就是打酱油的
if(b){
p.setName("李小文院士");
p.setCountry("中国");
b = false;
}
else{
p.setName("加来道雄博士");
p.setCountry("日本");
b = true;
}
//唤醒 并且这里注意 把flag改变成了 false
p.setFlag(false);
p.notify();
}
else
try {
//老样子 否则就过来阻塞
p.wait();
} catch (Exception e) {
// TODO: handle exception
}
}
}
}
}
class Saler implements Runnable{
private Production p = null;
//表明同步的锁!!!!
public Saler(Production p) {
this.p = p;
}
public void run() {
while(true){
synchronized (p) {
//上面的 isFlage被设定成 false了 所以这里要不等于 然后他们 就这样一直轮回下去 下面没了就让上面造
if(!p.isFlag()){
//获取前面的 赋值
System.out.println(p.getName()+":"+p.getCountry());
p.setFlag(true);
//唤醒 动起来
p.notify();
}
else{
try {
//阻塞
p.wait();
} catch (Exception e) {
// TODO: handle exception
}
}
}
}
}
}
public class ProductionDemo{
public static void main(String[] args) {
Production p = new Production();
Producer producer = new Producer(p);
Saler saler = new Saler(p);
Thread th1 = new Thread(producer);
Thread th2 = new Thread(saler);
th1.start();
th2.start();
}
}
小钢炮这个是同步函数的
public class ProductionDemo{
public static void main(String[] args) {
// 这是同步函数的
/* Production p = new Production();
Producer producer = new Producer(p);
Saler saler = new Saler(p);
Thread th1 = new Thread(producer);
Thread th2 = new Thread(saler);
th1.start();
th2.start();
*/
//同步代码块
Production p = new Production();
Producer pd = new Producer(p);
Saler s = new Saler(p);
Thread th1 = new Thread(pd);
Thread th2 = new Thread(s);
th1.start();
th2.start();
}
}
//同步代码块
class Production {
private String name;
private int num = 0;
private boolean b = false;
public boolean isB() {
return b;
}
public void setB(boolean b) {
this.b = b;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
class Producer implements Runnable {
private Production p = null;
public Producer(Production p) {
this.p = p;
}
public void run() {
while (true) {
synchronized (p) {
if (p.isB()) {
try {
p.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
p.setName("小钢炮");
p.setNum(p.getNum() + 1);
System.out.println("生产：" + p.getName() + p.getNum());
p.setB(true);
p.notify();
}
}
}
}
class Saler implements Runnable {
private Production p = null;
//获取定义的锁要一样
public Saler(Production p) {
this.p = p;
}
public void run() {
while (true) {
synchronized (p) {
if (!p.isB()) {
try {
//阻塞
p.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("卖：" + p.getName() + p.getNum());
p.setB(false);
//唤醒
p.notify();
}
}
}
}
然后了是多生产者和多消费者 嘿嘿上码:
package cn.java.thread1;
public class ProductionDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
Production2 p = new Production2();
Producer2 pd = new Producer2(p);
Saler2 s = new Saler2(p);
Thread th1 = new Thread(pd);
Thread th2 = new Thread(pd);
Thread th3 = new Thread(s);
Thread th4 = new Thread(s);
Thread th5 = new Thread(pd);
Thread th6 = new Thread(s);
th1.start();
th2.start();
th3.start();
th4.start();
th5.start();
th6.start();
}
}
class Production2 {
private String name;
private int num = 0;
private boolean b = false;
public boolean isB() {
return b;
}
public void setB(boolean b) {
this.b = b;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public synchronized void produce() {
//if (b) {
while (b) {
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
setName("小钢炮");
setNum(getNum() + 1);
System.out.println("生产：" + getName() + getNum());
setB(true);
//notify();
notifyAll();
}
public synchronized void sale() {
//if (!b) {
while(!b){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("卖：" + getName() + getNum());
setB(false);
//notify();
notifyAll();
}
}
class Producer2 implements Runnable {
private Production2 p = null;
public Producer2(Production2 p2) {
this.p = p2;
}
public void run() {
for (int i = 0; i < 100; i++) {
p.produce();
}
}
}
class Saler2 implements Runnable {
private Production2 p = null;
public Saler2(Production2 p2) {
this.p = p2;
}
public void run() {
for (int i = 0; i < 100; i++) {
p.sale();
}
}
}
Java线程同步锁的更多相关文章
- java 线程同步 原理 sleep和wait区别
java线程同步的原理java会为每个Object对象分配一个monitor, 当某个对象(实例)的同步方法(synchronized methods)被多个线程调用时,该对象的monitor将负责处 ...
- 【总结】Java线程同步机制深刻阐述
原文:http://hxraid.iteye.com/blog/667437 我们可以在计算机上运行各种计算机软件程序.每一个运行的程序可能包括多个独立运行的线程(Thread). 线程(Thread ...
- Java线程同步_1
Java线程同步_1 synchronized 该同步机制的的核心是同步监视器,任何对象都可以作为同步监视器,代码执行结束,或者程序调用了同步监视器的wait方法会导致释放同步监视器 synchron ...
- Java线程同步之一--AQS
Java线程同步之一--AQS 线程同步是指两个并发执行的线程在同一时间不同时执行某一部分的程序.同步问题在生活中也很常见,就比如在麦当劳点餐,假设只有一个服务员能够提供点餐服务.每个服务员在同一时刻 ...
- Java线程：锁
一.锁的原理 Java中每个对象都有一个内置锁,当程序运行到非静态的synchronized同步方法上时,自动获得与正在执行的代码类的当前实例(this实例)有关的锁.获得一个对象的锁也称为获取锁.锁 ...
- JAVA - 线程同步和线程调度的相关方法
JAVA - 线程同步和线程调度的相关方法 wait():使一个线程处于等待(阻塞)状态,并且释放所持有的对象的锁:wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等 ...
- Java线程同步的四种方式详解(建议收藏)
Java线程同步属于Java多线程与并发编程的核心点,需要重点掌握,下面我就来详解Java线程同步的4种主要的实现方式@mikechen 目录 什么是线程同步 线程同步的几种方式 1.使用sync ...
- java线程 同步临界区：thinking in java4 21.3.5
java线程 同步临界区:thinking in java4 21.3.5 thinking in java 4免费下载:http://download.csdn.net/detail/liangru ...
- Python之路(第四十四篇)线程同步锁、死锁、递归锁、信号量
在使用多线程的应用下,如何保证线程安全,以及线程之间的同步,或者访问共享变量等问题是十分棘手的问题,也是使用多线程下面临的问题,如果处理不好,会带来较严重的后果,使用python多线程中提供Lock ...
随机推荐
- Getting Real内容浓缩
今天看完,想整理一下,可能会更好,也给别人提供一个快速学习的途径第一章 什么是 Getting Real?表达形式省略.精炼.精益.敏捷.用户体验.迭代改进.产品简化.第二章 建构从简做得比竟争对手少 ...
- C++ 进制转换 十进制十六进制八进制二进制相互转换
思路: 下面我把相互转换的所有类型都写出来了.实际上都是通过十进制中转的,这样比较简单,写出X进制转成十进制和从十进制转成X进制的两份代码直接拷贝就完成了剩余的部分.哦,对,自己封装了一个charTo ...
- Ocelot中文文档-GraphQL
好吧!你明白我的意思Ocelot并不直接支持GraphQL,但有这么多人问起它,我想表明整合graphql-dotnet库是多么容易 请参阅示例项目OcelotGraphQL. 结合使用graphql ...
- Apache Flink 流处理实例
维基百科在 IRC 频道上记录 Wiki 被修改的日志,我们可以通过监听这个 IRC 频道,来实时监控给定时间窗口内的修改事件.Apache Flink 作为流计算引擎,非常适合处理流数据,并且,类似 ...
- MVC-AOP思想-Filter 三种注册方式
在ASP.NET MVC框架中,为我们提供了四种类型的Filter类型包括:IAuthorizationFilter.IActionFilter.IResultFilter.IExceptionFil ...
- JSF基础
JSF基础 1)JSF(JavaServer Faces)一种基于Java的Web应用的用户界面软件框架. 旨在降低web应用开发难度.减轻开发人员编写和维护web应用的负担. 一个基于JSF框架构建 ...
- Install and Configure Apache Kafka on Ubuntu 16.04
https://devops.profitbricks.com/tutorials/install-and-configure-apache-kafka-on-ubuntu-1604-1/ by hi ...
- 重载new和delete来检测内存泄漏
重载new和delete来检测内存泄漏 1. 简述 内存泄漏属于资源泄漏的一种,百度百科将内存泄漏分为四种:常发性内存泄漏.偶发性内存泄漏.一次性内存泄漏和隐式内存泄漏. 常发性指:内存泄漏的代 ...
- python的约束库constraint解决《2018刑侦科题目》
Github地址:https://github.com/ZJW9633/hello-word/blob/master/Xingzhenke 题目分析: 10道题互相关联,耦合性强,暴力求解需4^10种 ...
- 请求转发(forward)和重定向(redirect)的区别
转发不会改变地址栏,重定向会. 转发是请求一次,重定向请求两次. 转发过程中只有一个request对象产生,重定向是两个. 转发不能转发到站外,重定向可以发送到站外. 重定向的第2个请求的请求方式是什 ...