基础学习day11--多线程一线程的创建，运行，同步和锁
一、线程基本概述
1.1、进程和线程
进程：一个应用程序一般都是一个进程，正在进行的程序
每一个进程最少都有一个线程，都有一个执行顺序，该顺序是一个执行路径或者一个控制单元
线程：进程中一个独立的控制单元，线程控制着进程的执行。
windows中的任务管理器，可以查看进程，linux下通过ps命令
线程是进程的最小单位
线程依赖于进程
线程随着进程的创建和创建，随着进程的结束而消亡
如迅雷：可以同时开启多个下载，就是多线程
多个程序同时执行，时CPU在很快的切换，看上去是同时执行，实际上是在CPU在切换执行。
多线程存在的意义：可以让程序中的内容同时执行。
二、继承线程的创建
2.1、继承Thread，重写run方法
package com.pb.thread.demo1; /**
*
* @author Denny
* 继承Thread 类并重写run方法来创建线程类
*
*/
public class MyThread extends Thread { private int count; /*
* 重写run 方法
* @see java.lang.Thread#run()
*/
@Override
public void run(){
/*
* 要运行的代码块或者方法，在这里调用，或者直接写在这里
*/
while(count<10){
count++;
System.out.println("My thread run方法启动了"+count);
}
}
public static void main(String[] args) {
//声明线程类
MyThread mt=new MyThread();
//启动线程，JVM调用run方法
mt.start();
//主线程
for(int x=0;x<10;x++){
System.out.println("main thread"+x);
}
} }
多个线程都在抢占CPU的执行权，谁抢到，谁就执行
在某一时刻，只能有一个程序在运行
CPU在做着快速切换，以达到看上去是同时运行的效果。
多线程一个特性：随机性，谁抢到谁执行.
三、线程的运行和线程状态
3.1、调用start()方法
使该线程开始执行，Java虚拟机调用该线程的run()方法
为什么要重写run方法.
Thread类用于描述线程。
这个类定义一个功能，用于存储线程要运行的代码。该存储功能就是run方法.
也就是说,Thread类中的run方法是用于存储线程要运行的代码
如果直接调用run()方法，就是调用对象的普通方法一样.，仅仅是对象调用方法.线程创建了并没有运行。
只有start()才可以运行线程。
3.2、线程状态
新生：创建线程 new Thread()或者子类
运行:正在运行的线程,调用start()方法
冻结：已经创建的线程，但非运行状态的线程。sleep(long 毫秒), wait()线程等待，直到notify()唤醒才可以继续运行
临时状态阻塞：具备运行资格，但没有执行权，就是还没有被CPU切换到.
消亡：线程死亡stop(),或者线程运行完成。
四、获取线程对象
4.1、获取当前线程对象和名称
继承thread类实现线程，局部变量都有单独的一份不能共享数据
package com.pb.thread.demo1; /**
*
* @author Denny
* 继承Thread 类并重写run方法来创建线程类
*Thread.currentThread()，获取当前线程对象
*继承thread类实现线程，局部变量都有单独的一份不能共享数据
*/
public class MyThread extends Thread { public MyThread(String name){
super(name);
}
/*
* 重写run 方法
* @see java.lang.Thread#run()
*/
@Override
public void run(){
/*
* 要运行的代码块或者方法，在这里调用，或者直接写在这里
*/
for(int x=0;x<10;x++){ System.out.println("My thread run的名字:"+Thread.currentThread().getName()+","+x);
}
}
public static void main(String[] args) {
//声明线程类
MyThread mt1=new MyThread("mt1");
// mt1.setName("张三"); 设置线程名称
MyThread mt2=new MyThread("mt2");
//启动线程，JVM调用run方法
mt1.start();
mt2.start();
//主线程
for(int x=0;x<10;x++){
System.out.println(currentThread().getName()+","+x);
}
} }
示例：
五、接口实现线程
5.1、实现Runnable接口
重写run方法（）
实现接口的方式最大的好处是可以共享数据
示例：多窗口同时售票，
package com.pb.thread.demo1; /**
*
* @author Administrator 多个窗口同时卖票
*
*/
public class Ticket implements Runnable { private int tick = 100; public void run() { while (true) {
if (tick > 0) {
System.out.println(Thread.currentThread().getName()+"卖：" + tick--);
}else{
break;
}
}
}
public static void main(String[] args) {
//声明线程类
Ticket ticket=new Ticket();
//创建线程对象，并将类做为参数
Thread t1=new Thread(ticket);
t1.setName("一号窗口,");
Thread t2=new Thread(ticket);
t2.setName("二号窗口,");
Thread t3=new Thread(ticket);
t3.setName("三号窗口,");
Thread t4=new Thread(ticket);
t4.setName("四号窗口,");
t1.start();
t2.start();
t3.start();
t4.start(); } }
结果：
一号窗口,卖：100
一号窗口,卖：98
一号窗口,卖：97
一号窗口,卖：96
一号窗口,卖：95
一号窗口,卖：94
二号窗口,卖：99
二号窗口,卖：92
一号窗口,卖：93
一号窗口,卖：88
一号窗口,卖：87
一号窗口,卖：86
二号窗口,卖：89
二号窗口,卖：84
二号窗口,卖：83
二号窗口,卖：82
二号窗口,卖：81
二号窗口,卖：80
二号窗口,卖：79
二号窗口,卖：78
二号窗口,卖：77
二号窗口,卖：76
二号窗口,卖：75
二号窗口,卖：74
二号窗口,卖：73
二号窗口,卖：72
二号窗口,卖：71
二号窗口,卖：70
二号窗口,卖：69
二号窗口,卖：68
二号窗口,卖：67
二号窗口,卖：66
二号窗口,卖：65
二号窗口,卖：64
二号窗口,卖：63
二号窗口,卖：62
二号窗口,卖：61
二号窗口,卖：60
二号窗口,卖：59
二号窗口,卖：58
二号窗口,卖：57
二号窗口,卖：56
二号窗口,卖：55
二号窗口,卖：54
二号窗口,卖：53
二号窗口,卖：52
二号窗口,卖：51
二号窗口,卖：50
二号窗口,卖：49
二号窗口,卖：48
二号窗口,卖：47
二号窗口,卖：46
二号窗口,卖：45
二号窗口,卖：44
二号窗口,卖：43
二号窗口,卖：42
二号窗口,卖：41
二号窗口,卖：40
二号窗口,卖：39
二号窗口,卖：38
二号窗口,卖：37
二号窗口,卖：36
二号窗口,卖：35
二号窗口,卖：34
二号窗口,卖：33
二号窗口,卖：32
二号窗口,卖：31
二号窗口,卖：30
二号窗口,卖：29
二号窗口,卖：28
二号窗口,卖：27
二号窗口,卖：26
二号窗口,卖：25
二号窗口,卖：24
二号窗口,卖：23
二号窗口,卖：22
二号窗口,卖：21
三号窗口,卖：90
四号窗口,卖：91
三号窗口,卖：19
二号窗口,卖：20
一号窗口,卖：85
二号窗口,卖：16
三号窗口,卖：17
四号窗口,卖：18
三号窗口,卖：13
三号窗口,卖：11
三号窗口,卖：10
三号窗口,卖：9
三号窗口,卖：8
三号窗口,卖：7
三号窗口,卖：6
三号窗口,卖：5
三号窗口,卖：4
三号窗口,卖：3
三号窗口,卖：2
三号窗口,卖：1
二号窗口,卖：14
一号窗口,卖：15
四号窗口,卖：12
两种创建线程方式：
| 优点 | 缺点 | |
| 继承Thread类 |
1.编写简单 2.可以使用this关键字直接访问当前线程 |
无法继承其它类 无法实现数据共享 |
| 实现Runnable接口 |
1.可以继承其它类 2.多个线程之间可以使用同一个Runnable对象 3.可以共享数据 |
编程方式稍微复杂，如需访问当前线程，需要调用Thread类的currentThread()方法 |
六、线程安全
6.1、还是上面的例子
加上sleep(1000)睡觉1秒
package com.day10.thread.demo1;
public class Ticket implements Runnable {
private int num=100;
@Override
public void run() {
while(true){
if(num>0){
try {
Thread.sleep(1000); //当前线程睡觉1秒，毫秒单位
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+",卖出"+num--+"号票");
}
}
}
public static void main(String[] args) {
Ticket t=new Ticket();
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();
}
}
结果：
Picked up JAVA_TOOL_OPTIONS: -javaagent:/usr/share/java/jayatanaag.jar
Thread-0,卖出100号票
Thread-2,卖出99号票
Thread-1,卖出98号票
Thread-3,卖出97号票
Thread-0,卖出96号票
Thread-2,卖出95号票
Thread-1,卖出94号票
Thread-3,卖出93号票
Thread-0,卖出92号票
Thread-2,卖出91号票
Thread-1,卖出90号票
Thread-3,卖出89号票
Thread-0,卖出88号票
Thread-2,卖出87号票
Thread-1,卖出86号票
Thread-3,卖出85号票
Thread-0,卖出84号票
Thread-2,卖出83号票
Thread-1,卖出82号票
Thread-3,卖出81号票
Thread-0,卖出80号票
Thread-2,卖出79号票
Thread-1,卖出78号票
Thread-3,卖出77号票
Thread-0,卖出76号票
Thread-2,卖出75号票
Thread-1,卖出74号票
Thread-3,卖出73号票
Thread-0,卖出72号票
Thread-2,卖出71号票
Thread-1,卖出70号票
Thread-3,卖出69号票
Thread-0,卖出68号票
Thread-2,卖出67号票
Thread-1,卖出66号票
Thread-3,卖出65号票
Thread-0,卖出64号票
Thread-2,卖出63号票
Thread-1,卖出62号票
Thread-3,卖出61号票
Thread-0,卖出60号票
Thread-2,卖出59号票
Thread-1,卖出58号票
Thread-3,卖出57号票
Thread-0,卖出56号票
Thread-2,卖出55号票
Thread-1,卖出54号票
Thread-3,卖出53号票
Thread-0,卖出52号票
Thread-2,卖出51号票
Thread-1,卖出50号票
Thread-3,卖出49号票
Thread-0,卖出48号票
Thread-2,卖出47号票
Thread-1,卖出46号票
Thread-3,卖出45号票
Thread-0,卖出44号票
Thread-2,卖出43号票
Thread-1,卖出42号票
Thread-3,卖出41号票
Thread-0,卖出40号票
Thread-2,卖出39号票
Thread-1,卖出38号票
Thread-3,卖出37号票
Thread-0,卖出36号票
Thread-2,卖出35号票
Thread-1,卖出34号票
Thread-3,卖出33号票
Thread-0,卖出32号票
Thread-2,卖出31号票
Thread-1,卖出30号票
Thread-3,卖出29号票
Thread-0,卖出28号票
Thread-2,卖出27号票
Thread-1,卖出26号票
Thread-3,卖出25号票
Thread-0,卖出24号票
Thread-2,卖出23号票
Thread-1,卖出22号票
Thread-3,卖出21号票
Thread-0,卖出20号票
Thread-2,卖出19号票
Thread-1,卖出18号票
Thread-3,卖出17号票
Thread-0,卖出16号票
Thread-2,卖出15号票
Thread-1,卖出14号票
Thread-3,卖出13号票
Thread-0,卖出12号票
Thread-2,卖出11号票
Thread-1,卖出10号票
Thread-3,卖出9号票
Thread-0,卖出8号票
Thread-2,卖出7号票
Thread-1,卖出6号票
Thread-3,卖出5号票
Thread-0,卖出4号票
Thread-2,卖出3号票
Thread-1,卖出2号票
Thread-3,卖出1号票
Thread-0,卖出0号票
Thread-2,卖出-1号票
Thread-1,卖出-2号票
发现多卖票了，
为什么？因为卖票当前线程睡眠了1秒，其它线程就可以把这张票已经卖出了，
条件检查1>0,如果4个人同时检查，条件成立，就继续卖票就出现了，负数
怎么解决？给线程加锁
1. 多个线程在操作共享的数据。
2. 操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。
解决方式：就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算。必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。
看下面的同步synchronized
七、同步代码块
7.1、synchronized
同步代码块的格式：
synchronized(对象){
需要被同步的代码;
}
同步的好处：解决了线程的安全问题。
同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
同步的前提：必须有多个线程并使用同一个锁。
修改上面的代码
package com.day10.thread.demo1;
public class Ticket implements Runnable {
private int num=100;
@Override
public void run() {
while(true){
synchronized(this){
if(num>0){
try {
Thread.sleep(1000); //当前线程睡觉1秒，毫秒单位
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+",卖出"+num--+"号票");
}else{
break;
}
}
}
}
public static void main(String[] args) {
Ticket t=new Ticket();
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();
}
}
八、同步函数
8.1、同步方法
package com.day10.thread.demo2;
public class Account {
//余额
private double blance=500;
//取款
public void withDraw(int num){
blance=blance-num;
}
public double getBlance() {
return blance;
}
public void setBlance(double blance) {
this.blance = blance;
}
}
package com.day10.thread.demo2;
public class AccountThread implements Runnable {
private Account account=new Account();
@Override
public void run() {
for (int i = 0; i < 5; i++) {
if(account.getBlance()<0){
System.out.println("透支了!!");
}
makWithDraw(100); //每次取100
}
}
/*
* 取款的方法
*/
public void makWithDraw(int num){
//判断余额是不是大于要取款的数
if(account.getBlance()>=num){
System.out.println(Thread.currentThread().getName()+"：准备取款!");
try {
Thread.sleep(1000); //等待1秒
account.withDraw(num);
System.out.println(Thread.currentThread().getName()+"：取款完成!,当前余额为:"+account.getBlance());
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
System.out.println(Thread.currentThread().getName()+" 余额不足以支付当前取款， 余额为: "+account.getBlance());
}
}
}
package com.day10.thread.demo2;
public class Demo {
public static void main(String[] args) {
AccountThread at=new AccountThread();
Thread t1=new Thread(at);
t1.setName("张三");
Thread t2=new Thread(at);
t2.setName("张三老婆");
t1.start();
t2.start();
}
}
结果：
张三：准备取款!
张三老婆：准备取款!
张三：取款完成!,当前余额为:400.0
张三：准备取款!
张三老婆：取款完成!,当前余额为:300.0
张三老婆：准备取款!
张三：取款完成!,当前余额为:200.0
张三：准备取款!
张三老婆：取款完成!,当前余额为:100.0
张三老婆：准备取款!
张三：取款完成!,当前余额为:0.0
张三 余额不足以支付当前取款， 余额为: 0.0
张三 余额不足以支付当前取款， 余额为: 0.0
张三老婆：取款完成!,当前余额为:-100.0
透支了!!
张三老婆 余额不足以支付当前取款， 余额为: -100.0
透支了!!
张三老婆 余额不足以支付当前取款， 余额为: -100.0
加上同步关键字
/*
* 取款的方法
*/
public synchronized void makWithDraw(int num){
//判断余额是不是大于要取款的数
if(account.getBlance()>=num){
System.out.println(Thread.currentThread().getName()+"：准备取款!");
try {
Thread.sleep(1000); //等待1秒
account.withDraw(num);
System.out.println(Thread.currentThread().getName()+"：取款完成!,当前余额为:"+account.getBlance());
} catch (InterruptedException e) {
e.printStackTrace();
} }else{
System.out.println(Thread.currentThread().getName()+" 余额不足以支付当前取款， 余额为: "+account.getBlance());
}
}
结果:
张三：准备取款!
张三：取款完成!,当前余额为:400.0
张三老婆：准备取款!
张三老婆：取款完成!,当前余额为:300.0
张三：准备取款!
张三：取款完成!,当前余额为:200.0
张三：准备取款!
张三：取款完成!,当前余额为:100.0
张三：准备取款!
张三：取款完成!,当前余额为:0.0
张三 余额不足以支付当前取款， 余额为: 0.0
张三老婆 余额不足以支付当前取款， 余额为: 0.0
张三老婆 余额不足以支付当前取款， 余额为: 0.0
张三老婆 余额不足以支付当前取款， 余额为: 0.0
张三老婆 余额不足以支付当前取款， 余额为: 0.0
没有发生透支现象
同步代码块：
/*
* 取款的方法
*/
public void makWithDraw(int num){
synchronized(account){
//判断余额是不是大于要取款的数
if(account.getBlance()>=num){
System.out.println(Thread.currentThread().getName()+"：准备取款!");
try {
Thread.sleep(1000); //等待1秒
account.withDraw(num);
System.out.println(Thread.currentThread().getName()+"：取款完成!,当前余额为:"+account.getBlance());
} catch (InterruptedException e) {
e.printStackTrace();
} }else{
System.out.println(Thread.currentThread().getName()+" 余额不足以支付当前取款， 余额为: "+account.getBlance());
}
}
}
结果同上,没有发生透支现象
1. 同步函数的锁是固定的this。
2. 同步代码块的锁是任意的对象。
建议使用同步代码块。
九、同步锁
9.1、同锁
同步方法同步对象是this,同步代码块也可以使用this来同步
十、静态同步
10.1、静态同步
不是this，因为静态方法中也不可以定义this
静态进内存，内存中没有本类对象，但是一定有该类对应的字节码文件对象
静态的同步函数使用的锁是该函数所属字节码文件对象，可以用getClass方法获取，也可以用当前类名.class表示。
synchronizid(类名.class){ 或者对象.getClass
}
十一、单例模式加上同步懒汉式
11.1、懒汉式加锁
package com.day10.thread.demo2;
/**
*
* @author denny
*单例模式
*饿汉式，不存在复生成对象的问题
*懒汉工，加synchronize
*/
public class SingleDemo {
private static SingleDemo singleDemo; private SingleDemo(){ }
public static SingleDemo getNewIntance(){
if(singleDemo==null){//判断是不是空，不是空就直接返回，是空就加锁
synchronized(SingleDemo.class){ //加锁 //this.getClass() 直接写对象singleDemo.getClass()也行 if(singleDemo==null){
singleDemo=new SingleDemo();
}
}
}
return singleDemo; } }
十二、死锁
12.1、死锁常见情景之一：同步的嵌套。
class MyLock{
static Object lockA=new Object();
static Object lockB=new Object();
}
public class Demo implements Runnable {
private boolean flag;
public Demo(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
while (true) {
synchronized (MyLock.lockA) {
System.out.println("if.........lockA");
synchronized (MyLock.lockB) {
System.out.println("if.........lockB");
}
}
}
}
else {
while(true){
synchronized (MyLock.lockB) {
System.out.println("else.........lockB");
synchronized (MyLock.lockA) {
System.out.println("else.........lockA");
}
}
}
}
}
public static void main(String[] args) {
Thread t1 = new Thread(new Demo(true));
Thread t2 = new Thread(new Demo(false));
t1.start();
t2.start();
}
}
建议将要锁的对象，声明为static
基础学习day11--多线程一线程的创建，运行，同步和锁的更多相关文章
- Java多线程之线程的创建
好久没有更博客了,最近一直在忙工作的事情.现在终于空下来了,这2天会抓紧时间整理多线程和socket,把JavaSE结束掉. 关于多线程,首先会涉及到哪些东西呢?首先要了解线程,为什么要使用线程,线程 ...
- C/C++ Muti-Thread多线程编程学习（之）线程Thread | 创建、运行、结束
文章目录 前言 线程 Thread 创建线程 CreateThread _beginthread _beginthreadex pthread_create 线程运行 结束线程 前言 多线程(Mu ...
- Java基础加强之多线程篇(线程创建与终止、互斥、通信、本地变量)
线程创建与终止 线程创建 Thread类与Runnable接口的关系 public interface Runnable { public abstract void run(); } public ...
- Linux多线程编程——线程的创建与退出
POSIX线程标准:该标准定义了创建和操纵线程的一整套API.在类Unix操作系统(Unix.Linux.Mac OS X等)中,都使用Pthreads作为操作系统的线程.Windows操作系统也有其 ...
- .net学习之多线程、线程死锁、线程通信 生产者消费者模式、委托的简单使用、GDI（图形设计接口）常用的方法
1.多线程简单使用(1)进程是不执行代码的,执行代码的是线程,一个进程默认有一个线程(2)线程默认情况下都是前台线程,要所有的前台线程退出以后程序才会退出,进程里默认的线程我们叫做主线程或者叫做UI线 ...
- 黑马程序员——JAVA基础之简述多线程，两种创建多线程的方式
------- android培训.java培训.期待与您交流! ---------- 多线程: 进程和线程: 进程:是一个正在执行中的程序.每一个进程执行都有一个执行顺序.该顺序是一个执行路径,或者 ...
- Java并发学习之中的一个——线程的创建
本文是学习网络上的文章时的总结,感谢大家无私的分享. 1.与每一个Java语言中的元素一样,线程是对象.在Java中,我们有两种方式创建线程: a.通过直接继承thread类,然后覆盖run方法. b ...
- java学习笔记 --- 多线程（线程安全问题——同步代码块）
1.导致出现安全问题的原因: A:是否是多线程环境 B:是否有共享数据 C:是否有多条语句操作共享数据 2.解决线程安全问题方法: 同步代码块: synchronized(对象){ 需要同步的代码; ...
- (C#- 多线程) 在线程中创建object，共享问题。
研究如下问题: 1. 在一个进程的主线程中创建一个Object,其他线程都可以访问这个Object,并操作Object的方法. - 多线程同步问题. 2. 在一个进程的多个线程里面,每个线程都创建同一 ...
- 0038 Java学习笔记-多线程-传统线程间通信、Condition、阻塞队列、《疯狂Java讲义 第三版》进程间通信示例代码存在的一个问题
调用同步锁的wait().notify().notifyAll()进行线程通信 看这个经典的存取款问题,要求两个线程存款,两个线程取款,账户里有余额的时候只能取款,没余额的时候只能存款,存取款金额相同 ...
随机推荐
- 看那记不住命令的猿，如何使用GitHub
什么是GitHub呢? GitHub是什么?好吧, 请看百科:http://baike.baidu.com/view/3366456.htm 准备:msysgit.tortoisegit 首先,我们得 ...
- Understanding CMS GC Logs--转载
原文地址:https://blogs.oracle.com/poonam/entry/understanding_cms_gc_logs Understanding CMS GC Logs By Po ...
- Java后端书架
本书架主要针对Java后端开发与架构. 更新记录:4.0版把第五部份-具体技术的书整块拿掉了.<TCP/IP详解 卷1:协议>出到了第二版,增加<SRE:Google运维解密> ...
- Linux - 常见Shell文本处理方法
Common Shell Text Processing 珠玉在前,不再赘言. Linux Shell 文本处理工具集锦:http://blog.jobbole.com/99063/ 数据工程师常用的 ...
- 你不一定知道的几个很有用的 Git 命令
这里给大家分享一些很有用的 Git 命令,其中很多用法你可能都不知道,无论你是工作在团队环境中或在您的个人项目中,这些命令将对你帮助很大,让你可以更加高效的进行项目开发,更轻松愉快的工作和生活. 您可 ...
- n 后问题
n后问题,解决思路:假设每个皇后占一行(且第i个皇后放在第i - 1 行),依次去尝试下一个皇后该放在该行的哪一列 #include<iostream> #include<cmath ...
- Android的Activity生命周期
Android的Activity就相当于Windows Form中的Form,它的创建和销毁也是有一个生命周期的.主要经过这么7个阶段: 创建Activity:onCreate() 启动Activ ...
- Android、iOS和Windows Phone中的推送技术
推送并不是什么新技术,这种技术在互联网时代就已经很流行了.只是随着进入移动互联网时代,推送技术显得更加重要.因为在智能手机中,推送从某种程度上,可以取代使用多年的短信,而且与短信相比,还可以向用户展示 ...
- 准备.Net转前端开发-WPF界面框架那些事，值得珍藏的8个问题
题外话 不出意外,本片内容应该是最后一篇关于.Net技术的博客,做.Net的伙伴们忽喷忽喷..Net挺好的,微软最近在跨平台方面搞的水深火热,更新也比较频繁,而且博客园的很多大牛也写的有跨平台相关技术 ...
- 已超过传入消息(65536)的最大消息大小配额。若要增加配额，请使用相应绑定元素上的 MaxReceivedMessageSize 属性。
错误:已超过传入消息(65536)的最大消息大小配额.若要增加配额,请使用相应绑定元素上的 MaxReceivedMessageSize 属性. 或者 错误:反序列化操作“GetAllUserData ...