java socket 并发_java高并发synchronized学习

1.synchronized的作用：同步方法支持一种简单的策略来防止线程干扰和内存一致性的错误：如果一个对象对多个线程可见，则对该对象的所有读取或写入都是通过同步方法来完成的。总的来说是能够在同一时候保证最多只有一个线程执行该段代码，以达到安全的效果。

2.synchronized是java的关键字，被java语言原生支持，是最基本的互斥同步手段

代码演示

public class DisapperRequest1 implements Runnable {

static int k=0;

static DisapperRequest1 disapperRequest1=new DisapperRequest1();

@Override

public void run() {

for(int i=0;i<100000;i++)

{

k++;

}

}

public static void main(String[] args) throws InterruptedException {

Thread thread=new Thread(disapperRequest1);

Thread thread1=new Thread(disapperRequest1);

thread.start();

thread1.start();

/**join的意思是使得放弃当前线程的执行，并返回对应的线程，例如下面代码的意思就是：

程序在main线程中调用t1线程的join方法，则main线程放弃cpu控制权，并返回t1线程继续执行直到线程t1执行完毕

所以结果是t1线程执行完后，才到主线程执行，相当于在main线程中同步t1线程，t1执行完了，main线程才有执行的机会

thread.join();

thread1.join();

System.out.println(k);

}

}

join方法是通过调用线程的wait方法来达到同步的目的的。例如，A线程中调用了B线程的join方法，则相当于A线程调用了B线程的wait方法，在调用了B线程的wait方法后，A线程就会进入阻塞状态

最后的结果总是小于或等于20W 这跟预期的结果不一样。count++看上去只有一个操作，实际上是有三个操作的1.读取count的值 2.讲count加1 3.将count的值加入内存

当count的值还没有加入内存的时候count就已经读取了。这样就会造成线程不安全。3.Synchronized两种方法用法：对象锁：包括方法锁(默认锁对象为this当前的实例的对象)和同步代码块锁(自己指定锁对象)。类锁：指的是用Synchronized修饰的静态方法或者指定锁对象为class对象

代码块形式要手动指定对象，方发锁形式：Synchronized修饰普通方法，锁对象默认为this

代码块锁：isAlive方法判断线程是否存活

public class SynchronizedObjectCodeBlock2 implementsRunnable {static SynchronizedObjectCodeBlock2 instance=newSynchronizedObjectCodeBlock2();

@Overridepublic voidrun() {synchronized(this) {

System.out.println(Thread.currentThread().getName());try{

Thread.sleep(1000);

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+ "运行结束");

}

}public static voidmain(String[] args) {

Thread t1=newThread(instance);

Thread t2=newThread(instance);

t1.start();

t2.start();while (t1.isAlive()||t2.isAlive())

{

}

System.out.println("结束");

}

}

当用两个锁的情况：当不是同一把锁的时候，可以并行运行

public class SynchronizedObjectCodeBlock2 implementsRunnable {static SynchronizedObjectCodeBlock2 instance=newSynchronizedObjectCodeBlock2();

Object lock1=newObject();

Object lock2=newObject();

@Overridepublic voidrun() {synchronized(lock1) {

System.out.println(Thread.currentThread().getName()+"lock1");try{

Thread.sleep(5000);

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+ "运行结束1");

}synchronized(lock2) {

System.out.println(Thread.currentThread().getName()+"lock2");try{

Thread.sleep(5000);

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+ "运行结束2");

}

}public static voidmain(String[] args) {

Thread t1=newThread(instance);

Thread t2=newThread(instance);

t1.start();

t2.start();while (t1.isAlive()||t2.isAlive())

{

}

System.out.println("结束");

}

}

对象锁：Synchronized修饰普通的方法，默认锁对象为this

packagecom.xiaoqiang.sychronized;public class SynchronizedObjectMethod3 implementsRunnable {static SynchronizedObjectMethod3 instance=newSynchronizedObjectMethod3();

@Overridepublic voidrun() {

method();

}public static voidmain(String[] args) {

Thread t1=newThread(instance);

Thread t2=newThread(instance);

t1.start();

t2.start();while (t1.isAlive()||t2.isAlive())

{

}

System.out.println("结束");

}public synchronized voidmethod()

{

System.out.println(Thread.currentThread().getName()+"lock1");try{

Thread.sleep(5000);

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+ "运行结束1");

}

}

类锁：

1.staic 类锁：假如不在method中加入staic修饰的话，两个不同的静态对象就会并行执行run方法

packagecom.xiaoqiang.sychronized;public class SynchronizedClassStatic4 implementsRunnable {static SynchronizedClassStatic4 instance1=newSynchronizedClassStatic4();static SynchronizedClassStatic4 instance2=newSynchronizedClassStatic4();

@Overridepublic voidrun() {

method();

}public static voidmain(String[] args) {

Thread t1=newThread(instance1);

Thread t2=newThread(instance2);

t1.start();

t2.start();while (t1.isAlive()||t2.isAlive())

{

}

System.out.println("结束");

}public synchronized voidmethod()

{

System.out.println(Thread.currentThread().getName()+"lock1");try{

Thread.sleep(5000);

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+ "运行结束1");

}

}

如果用 static 修饰method方法的话就会串行进行

packagecom.xiaoqiang.sychronized;public class SynchronizedClassStatic4 implementsRunnable {static SynchronizedClassStatic4 instance1=newSynchronizedClassStatic4();static SynchronizedClassStatic4 instance2=newSynchronizedClassStatic4();

@Overridepublic voidrun() {

method();

}public static voidmain(String[] args) {

Thread t1=newThread(instance1);

Thread t2=newThread(instance2);

t1.start();

t2.start();while (t1.isAlive()||t2.isAlive())

{

}

System.out.println("结束");

}public static synchronized voidmethod()

{

System.out.println(Thread.currentThread().getName()+"lock1");try{

Thread.sleep(5000);

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+ "运行结束1");

}

}

2.。*.class 类锁

同一个类锁的实现

packagecom.xiaoqiang.sychronized;public class SynchronizedClassClass5 implementsRunnable {static SynchronizedClassClass5 instance1=newSynchronizedClassClass5();static SynchronizedClassClass5 instance2=newSynchronizedClassClass5();

@Overridepublic voidrun() {

method();

}public static voidmain(String[] args) {

Thread t1=newThread(instance1);

Thread t2=newThread(instance2);

t1.start();

t2.start();while (t1.isAlive()||t2.isAlive())

{

}

System.out.println("结束");

}private voidmethod() {synchronized (SynchronizedClassClass5.class) {

System.out.println(Thread.currentThread().getName()+ "lock1");try{

Thread.sleep(5000);

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+ "运行结束1");

}

}

}

4.Synchronized的核心思想：

1.一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待。

2.每个实例都对应自己的一把锁，不同实例之间互不影响。例外：锁对象是*.class或者用Synchronized修饰的是static方法时，所有对象都共用同一把锁

3.无论是正常运完毕或者方法抛出异常，都会释放锁。

5.Synchronized的性质

1.可重入性：指的是同一线程外层函数获取到锁后之后，内层函数可以直接再次获取该锁。

好处：避免死锁，提高封装性。

粒度(范围):线程而非调用

2.不可中断性：一旦这个锁已经被别人获得了，如果我还想获得，就必须等待或者阻塞，直到别的线程释放这个锁。如果别人永远不释放锁，那么只能永远的等待下去。

6.Synchronized的缺点：

效率低：锁的释放情况少，试图获得锁的时候不能设置超时，不能中断一个正试图获得锁的线程。

不够灵活：加锁和释放锁的时机单一，每个锁仅有单一的条件，可能是不够的。

无法知道是否成功获取到锁