Holding Side Control & North South, Taking the Back vs Single Leg

Hand Fighting & Engaging from Butterfly vs Standing Opponent

Constantly pulling hand, leg, head, fighting for the control.

if you cant hold with your arm, hold with your feet.

Holding Side Control & North South, Taking the Back vs Single Leg
In side control, when they have underhook, switch to north south(where have more control on hip). Keep the pressure on his chest, when he spins, take the back.




  • The process of oxidation in the human body produces unstable chemicals called free radicals, which damage cell membranes and other structures.
  • Free radicals have been linked to a variety of diseases, including heart disease and certain cancers.
  • Antioxidants are compounds in foods that scavenge and neutralise free radicals.
  • Evidence suggests that antioxidant supplements do not work as well as the naturally occurring antioxidants in foods such as fruits and vegetables.




Oxidation can be accelerated by stress, cigarette smoking, alcohol, sunlight, pollution and other factors. 压力,抽烟,喝酒,UV,污染都会加速氧化。。也就是衰老变快。。赶紧多吃维C顶住。。

The effect of free radicals

Some conditions caused by free radicals include:

  • deterioration of the eye lens, which contributes to blindness 加速近视
  • inflammation of the joints (arthritis) 关节炎
  • damage to nerve cells in the brain, which contributes to conditions such as Parkinson’s or Alzheimer’s disease 变笨
  • acceleration of the ageing process 加速变老
  • increased risk of coronary heart disease, since free radicals encourage low-density lipoprotein (LDL) cholesterol to stick to artery walls 心脏病
  • certain cancers, triggered by damaged cell DNA. 癌症

Sources of antioxidants

Plant foods are rich sources of antioxidants. They are most abundant in fruits and vegetables, as well as other foods including nuts, wholegrains and some meats, poultry and fish.

Good sources of specific antioxidants include:

  • allium sulphur compounds – leeks, onions and garlic
  • anthocyanins – eggplant, grapes and berries
  • beta-carotene – pumpkin, mangoes, apricots, carrots, spinach and parsley
  • catechins – red wine and tea
  • copper – seafood, lean meat, milk and nuts
  • cryptoxanthins – red capsicum, pumpkin and mangoes
  • flavonoids – tea, green tea, citrus fruits, red wine, onion and apples
  • indoles – cruciferous vegetables such as broccoli, cabbage and cauliflower
  • isoflavonoids – soybeans, tofu, lentils, peas and milk
  • lignans – sesame seeds, bran, whole grains and vegetables
  • lutein – green, leafy vegetables like spinach, and corn
  • lycopene – tomatoes, pink grapefruit and watermelon
  • manganese – seafood, lean meat, milk and nuts
  • polyphenols – thyme and oregano
  • selenium – seafood, offal, lean meat and whole grains
  • vitamin A – liver, sweet potatoes, carrots, milk, and egg yolks
  • vitamin C – oranges, blackcurrants, kiwifruit, mangoes, broccoli, spinach, capsicum and strawberries
  • vitamin E – vegetable oils (such as wheatgerm oil), avocados, nuts, seeds and whole grains
  • zinc – seafood, lean meat, milk and nuts
  • zoochemicals – red meat, offal and fish. Also derived from the plants that animals eat.








REST constraints

• It must be a client-server system
• It has to be stateless—there should be no need for the service to keep users’
sessions; in other words, each request should be independent of others
• It has to support a caching system—the network infrastructure should
support cache at different levels
• It has to be uniformly accessible—each resource must have a unique address
and a valid point of access
• It has to be layered—it must support scalability
• It should provide code on demand—although this is an optional constraint,
applications can be extendable at runtime by allowing the downloading of
code on demand, for example, Java Applets

Coding styles – efficient code writing

The Single Responsibility Principle 

Click to access srp.pdf

one class should only have one responsibility. for example, in a server and client example. Client might have functions of make connection and sending messages. it sounds perfect reasonable but it actually has two responsibilities. The drawback of this is 1. eg when two different application use this class. one might only use the connecting function whereas the other one using chatting function. they have to include both codes in when compile. 2 when they change some code for connection method. it might result chatting function in class not working.

The Open-Closed Principle

A method should be deigned open to the extension but closed for the modification. The key is using abstraction. For example, you might have a method of drawShapes(ShapeType shapeType). in the method, you have case “SQUARE”, case “RECTANGLE” and so on. To add a CIRCLE in, you will have to edit the method body. Instead, you can have a interface of Shape, using add(Shape shape) to add in additional shapes. then iterate the list and draw the shapes. in this way, the principle is maintained.

Java Synchronization Tutorial : What, How and Why? Read more: http://javarevisited.blogspot.com/2011/04/synchronization-in-java-synchronized.html#ixzz3ilDfAUs9

Multit-hreading and synchronization is a very important topic for any Java programmer. Good knowledge of multithreading, synchronization, and thread-safety can put you in front of other developers, at same time it’s not easy to master these concept. In fact writing correct concurrent code is one of the hardest thing, even in Java, which has several inbuilt synchronization utilities. In this Java synchronization tutorial we will learn what is meaning of Synchronization in Java, Why do we need Synchronization in Java, What is java synchronized keyword, examples of using Java synchronized method and blocks, What can happen in multithreading code in absence of synchronized constructs, tips to avoid mistakes, while locking critical section in Java and some of importantpoints about synchronization in Java. Since Java provides different constructs to provide synchronization and locking e.g. volatile keyword, atomic variable, explicitly locking using java.util.concurrent.lock.Lock interface and there popular implementations e.g. ReentrantLock and ReentrantReadWriteLock, It becomes even more important to understand difference between synchronized and other constructs. Remember, clear understanding of synchronization is must to write correct concurrent code in Java, which is free of multithreading issues like deadlock, race conditions and thread-safety. I am sure, things learned in this Java synchronization tutorial will help. Once you gone through this article, You can further read Java Concurrency in Practice to develop your concept.  That’s the one of those book which every Java developer must read.

What is Synchronization in Java

Synchronization in Java is an important concept since Java is a multi-threaded language where multiple threads run in parallel to complete program execution. In multi-threaded environment synchronization of Java object or synchronization of Java class becomes extremely important. Synchronization in Java is possible by using Java keywords “synchronized” and “volatile”. Concurrent access of shared objects in Java introduces to kind of errors: thread interference and memory consistency errors and to avoid these errors you need to properly synchronize your Java object to allow mutual exclusive access of critical section to two threads. By the way This Java Synchronization tutorial is in continuation of my article How HashMap works in Java  and difference between HashMap and Hashtable in Java  if you haven’t read already you may find some useful information based on my experience in Java Collections.

Why do we need Synchronization in Java?

If your code is executing in multi-threaded environment, you need synchronization for objects, which are shared among multiple threads, to avoid any corruption of state or any kind of unexpected behavior. Synchronization in Java will only be needed if shared object is mutable. if your shared object is either read only or immutable object, than you don’t need synchronization, despite running multiple threads. Same is true with what threads are doing with object if all the threads are only reading value then you don’t require synchronization in Java. JVM guarantees that Java synchronized code will only be executed by one thread at a time. In Summary Java synchronized Keyword provides following functionality essential for concurrent programming :

1) synchronized keyword in Java provides locking, which ensures mutual exclusive access of shared resource and prevent data race.

2) synchronized keyword also prevent reordering of code statement by compiler which can cause subtle concurrent issue if we don’t use synchronized or volatile keyword.

3) synchronized keyword involve locking and unlocking. before entering into synchronized method or block thread needs to acquire the lock, at this point it reads data from main memory than cache and when it release the lock, it flushes write operation into main memory which eliminates memory inconsistency errors.

Synchronized keyword in Java

Prior to Java 1.5 synchronized keyword was only way to provide synchronization of shared object in Java. Any code written by using  synchronized block or enclosed inside synchronized method will be mutually exclusive, and can only be executed by one thread at a time. You can have both static synchronized method and non static synchronized method and synchronized blocks in Java but we can not have synchronized variable in java. Using synchronized keyword with variable is illegal and will result in compilation error. Instead of synchronized variable in Java, you can have java volatile variable, which will instruct JVM threads to read value of volatile variable from main memory and don’t cache it locally. Block synchronization in Java is preferred over method synchronization in Java because by using block synchronization, you only need to lock the critical section of code instead of whole method. Since synchronization in Java comes with cost of performance, we need to synchronize only part of code which absolutely needs to be synchronized.

Example of Synchronized Method in Java

Using synchronized keyword along with method is easy just apply synchronized keyword in front of method. What we need to take care is that static synchronized method locked on class object lock and non static synchronized method locks on current object (this). So it’s possible that both static and non static java synchronized method running in parallel.  This is the common mistake a naive developer do while writing Java synchronized code.

public class Counter{ private static int count = 0; public static synchronized int getCount(){ return count; } public synchoronized setCount(int count){ this.count = count; } }

In this example of Java synchronization code is not properly synchronized because both getCount() and setCount() are not getting locked on same object and can run in parallel which may results in incorrect count. Here getCount() will lock inCounter.class object while setCount() will lock on current object (this). To make this code properly synchronized in Java you need to either make both method static or non static or use java synchronized block instead of java synchronized method.By the way this is one of the common mistake Java developers make while synchronizing their code.

Example of Synchronized Block in Java

Using synchronized block in java is also similar to using synchronized keyword in methods. Only important thing to note here is that if object used to lock synchronized block of code, Singleton.class in below example is null then Java synchronized block will throw a NullPointerException.

public class Singleton{ private static volatile Singleton _instance; public static Singleton getInstance(){ if(_instance == null){ synchronized(Singleton.class){ if(_instance == null) _instance = new Singleton(); } } return _instance; }

This is a classic example of double checked locking in Singleton. In this example of Java synchronized code, we have made only critical section (part of code which is creating instance of singleton) synchronized and saved some performance. If you make wholemethod synchronized than every call of this method will be blocked, while you only need blocking to create singleton instance on first call. By the way, this is not the only way to write threadsafe singleton in Java. You can use Enum, or lazy loading to avoid thread-safety issue during instantiation. Even above code will not behave as expected because prior to Java 1.5, double checked locking was broker and even with volatile variable you can view half initialized object. Introduction of Java memory model and happens before guarantee in Java 5 solves this issue. To read more about Singleton in Java see that.

Important points of synchronized keyword in Java

  1. Synchronized keyword in Java is used to provide mutual exclusive access of a shared resource with multiple threads in Java. Synchronization in Java guarantees that, no two threads can execute a synchronized methodwhich requires same lock simultaneously or concurrently.
  1. You can use java synchronized keyword only on synchronized method or synchronized block.
  1. When ever a thread enters into java synchronized method or block it acquires a lock and whenever it leaves java synchronized method or block it releases the lock. Lock is released even if thread leaves synchronizedmethod after completion or due to any Error or Exception.
  1. Java Thread acquires an object level lock when it enters into an instance synchronized java method and acquires a class level lock when it enters into static synchronized java method.
  1. Java synchronized keyword is re-entrant in nature it means if a java synchronized method calls another synchronized method which requires same lock then current thread which is holding lock can enter into that method without acquiring lock.
  1. Java Synchronization will throw NullPointerException if object used in java synchronized block is null e.g. synchronized (myInstance) will throws java.lang.NullPointerException if myInstance is null.
  1. One Major disadvantage of Java synchronized keyword is that it doesn’t allow concurrent read, which can potentially limit scalability. By using concept of lock stripping and using different locks for reading and writing, you can overcome this limitation of synchronized in Java. You will be glad to know that java.util.concurrent.locks.ReentrantReadWriteLock provides ready made implementation of ReadWriteLock in Java.
  1. One more limitation of java synchronized keyword is that it can only be used to control access of shared object within the same JVM. If you have more than one JVM and need to synchronized access to a shared file system or database, the Javasynchronized keyword is not at all sufficient. You need to implement a kind of global lock for that.
  1. Java synchronized keyword incurs performance cost. Synchronized method in Java is very slow and can degrade performance. So use synchronization in java when it absolutely requires and consider using java synchronized block for synchronizing critical section only.
  1. Java synchronized block is better than java synchronized method in Java because by using synchronized block you can only lock critical section of code and avoid locking whole method which can possibly degrade performance. A good example of java synchronization around this concept is getInstance() method Singleton class. See here.
  1. Its possible that both static synchronized and non static synchronized method can run simultaneously or concurrently because they lock on different object.
  1. From java 5 after change in Java memory model reads and writes are atomic for all variables declared using volatile keyword (including long and double variables) and simple atomic variable access is more efficient instead of accessing these variables via synchronized java code. But it requires more care and attention from the programmer to avoid memory consistency errors.
  1. Java synchronized code could result in deadlock or starvation while accessing by multiple thread if synchronization is not implemented correctly. To know how to avoid deadlock in java see here.
  1. According to the Java language specification you can not use Java synchronized keyword with constructor it’s illegal and result in compilation error. So you can not synchronized constructor in Java which seems logical because other threads cannot see the object being created until the thread creating it has finished it.
  1. You cannot apply java synchronized keyword with variables and can not use java volatile keyword with method.
  1. Java.util.concurrent.locks extends capability provided by java synchronized keyword for writing more sophisticated programs since they offer more capabilities e.g. Reentrancy and interruptible locks.
  1. Java synchronized keyword also synchronizes memory. In fact java synchronized synchronizes the whole of thread memory with main memory.
  1. Important method related to synchronization in Java are wait(), notify() and notifyAll() which is defined in Object class. Do you know, why they are defined in java.lang.object class instead of java.lang.Thread? You can find some reasons, which make sense.
  2. Do not synchronize on non final field on synchronized block in Java. because reference of non final field may change any time and then different thread might synchronizing on different objects i.e. no synchronization at all. example of synchronizing on non final field :

private String lock = new String(“lock”); synchronized(lock){ System.out.println(“locking on :” + lock); }

any if you write synchronized code like above in java you may get warning “Synchronization on non-final field”  in IDE like Netbeans and InteliJ

  1. Its not recommended to use String object as lock in java synchronized block because string is immutable object and literal string and interned string gets stored in String pool. so by any chance if any other part of code or any third party library used same String as there lock then they both will be locked on same object despite being completely unrelated which could result in unexpected behavior and bad performance. instead of String object its advised to use new Object() for Synchronization in Java on synchronized block.

private static final String LOCK = “lock”; //not recommended private static final Object OBJ_LOCK = new Object(); //better public void process() { synchronized(LOCK) { …….. } }

  1. From Java library Calendar and SimpleDateFormat classes are not thread-safe and requires external synchronization in Java to be used in multi-threaded environment.

Probably most important point about Synchronization in Java is that, in the absence of synchronized keyword or other construct e.g. volatile variable or atomic variable, compiler, JVM and hardware are free to make optimization, assumption, reordering or caching of code and data, which can cause subtle concurrency bugs in code. By introducing synchronization by using volatile, atomic variable or synchronized keyword, we instruct compiler and JVM to not to do that.
Update 1: Recently I have been reading several Java Synchronization and Concurrency articles in internet and I come across jeremymanson’s blog which works in google and has worked on JSR 133 Java Memory Model, I would recommend some of this blog post for every java developer, he has covered certain details about concurrent programming , synchronization and volatility in simple and easy to understand language, here is the link atomicity, visibility and ordering.

Update 2:  I am grateful to my readers, who has left some insightful comments on this post. They have shared lots of good information and experience and to provide them more exposure, I am including some of there comments on main article, to benefit new readers.

@Vikas wrote
Good comprehensive article about synchronized keyword in Java. to be honest I have never read all these details about synchronized block or method at one place. you may want to highlight some limitation of synchronized keyword in Java which is addressed by explicit locking using new concurrent package and Lock interface :

1. synchronized keyword doesn’t allow separate locks for reading and writing. as we know that multiple thread can read without affecting thread-safety of class, synchronized keyword suffer performance due to contention in case of multiple reader and one or few writer.

2. if one thread is waiting for lock then there is no way to time out, thread can wait indefinitely for lock.

  1. on similar note if thread is waiting for lock to acquired there is no way to interrupt the thread.

All these limitation of synchronized keyword is addressed and resolved by using ReadWriteLock and ReentrantLock in Java 5.

@George wrote
Just my 2 cents on your great list of Java Synchronization facts and best practices :
1) synchronized keyword in internally implemented using two byte code instructions MonitorEnter and MonitorExit, this is generated by compiler. Compiler also ensures that there must be a MonitorExit for every MonitorEnter in different code path e.g. normal execution and abrupt execution, because of Exception.

2) java.util.concurrent package different locking mechanism than provided by synchronized keyword, they mostly used ReentrantLock, which internally use CAS operations, volatile variables and atomic variables to get better performance.
3) With synchronized keyword, you have to leave the lock, once you exist a synchronized method or block, there is no way you can take the lock to other method. java.util.concurrent.locks.ReentrantLock solves this problem by providing control for acquiring and releasing lock, which means you can acquire lock in method A and can release in method B, if they both needs to be locked in same object lock. Though this could be risky as compiler will neither check nor warn you about any accidental leak of locks. Which means, this can potentially block other threads, which are waiting for same lock.

4) Prefer ReentrantLock over synchronized keyword, it provides more control on lock acquisition, lock release and better performance compared to synchronized keyword.
5) Any thread trying to acquire lock using synchronized method will block indefinitely, until lock is available. Instead this, tryLock() method of java.util.concurrent.locks.ReentrantLock will not block if lock is not available.
Having said that, I must say, lots of good information.

Recommend Books to learn Synchronization and Concurrency in Java

Synchronization and Concurrency is complex topic in Java and it’s not easy to master them. Even more experienced Java developers struggle to write correct concurrent code in Java. I would highly recommend following Java books to master multi-threading, synchronization and Concurrency.

Read more: http://javarevisited.blogspot.com/2011/04/synchronization-in-java-synchronized.html#ixzz3ilDqjVzf