程式扎記

Source From Here
Question
How do I configure Linux system firewall to allow incoming VNC connections?

How-To
VNC server listens on the following TCP ports:

=> VNC server on display 0 will listen on TCP ports 5800, 5900 and 6000
=> VNC server on display 1 will listen on TCP ports 5801, 5901 and 6001
=> VNC server on display N will listen on TCP ports 580N, 590N and 600N

In other words a VNC server listens for a VNC client on TCP ports 5800+N, 5900+N, and 6000+N where N is the display which starts at zero. So,

5800+N – Java-based vncviewer;
5900+N – VNC Client Port;
6000+N – X Server port.

Find Out VNC Port
Type the following command:

# netstat -tulp | grep vnc
tcp 0 0 0.0.0.0:5901 0.0.0.0:* LISTEN 3240/Xvnc

Update /etc/sysconfig/iptables
Edit /etc/sysconfig/iptables file:

view plaincopy to clipboardprint?
...  
-A INPUT -p tcp -m state --state NEW -m tcp --dport 5801 -j ACCEPT  
-A INPUT -p tcp -m state --state NEW -m tcp --dport 5901 -j ACCEPT  
-A INPUT -p tcp -m state --state NEW -m tcp --dport 6001 -j ACCEPT  

Save and close the file. Restart iptables:

# service iptables restart

A Note About Other Linux Distributions
/etc/sysconfig/iptables works only on RHEL / CentOS / Fedora Linux. For other distros update your iptables shell script as follows:

# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 5801 -j ACCEPT
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 5901 -j ACCEPT
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 6001 -j ACCEPT
# service iptables save

Source From Here
Preface
HashMap is a very powerful data structure in Java. We use it everyday and almost in all applications. There are quite a few examples which I have written before on How to Implement Threadsafe cache, How to convert HashMap to Arraylist? We used HashMap in both below examples but those are pretty simple use cases of HashMap. HashMap is a non-synchronized collection class.

Do you have any of below questions?

* What’s the difference between ConcurrentHashMap and Collections.synchronizedMap(Map)?
* What’s the difference between ConcurrentHashMap and Collections.synchronizedMap(Map) in term of performance?
* ConcurrentHashMap vs Collections.synchronizedMap(Map)
* Popular HashMap and ConcurrentHashMap interview questions

In this tutorial we will go over all above queries and reason why and how we could Synchronize Hashmap?

Why?
The Map object is an associative containers that store elements, formed by a combination of a uniquely identify key and a mapped value. If you have very highly concurrent application in which you may want to modify or read key value in different threads then it’s ideal to use Concurrent Hashmap. Best example is Producer Consumer which handles concurrent read/write.

So what does the thread-safe Map means? If multiple threads access a hash map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally to avoid an inconsistent view of the contents.

How?
There are two ways we could synchronized HashMap:

1. Java Collections synchronizedMap() method
2. Use ConcurrentHashMap

- HashMap Vs. synchronizedMap Vs. ConcurrentHashMap

view plaincopy to clipboardprint?
//Hashtable  
Map normalMap = new Hashtable();  
  
//synchronizedMap  
synchronizedHashMap = Collections.synchronizedMap(new HashMap());  
  
//ConcurrentHashMap  
concurrentHashMap = new ConcurrentHashMap();  

ConcurrentHashMap

* You should use ConcurrentHashMap when you need very high concurrency in your project.
* It is thread safe without synchronizing the whole map.
* Reads can happen very fast while write is done with a lock.
* There is no locking at the object level.
* The locking is at a much finer granularity at a hashmap bucket level.
* ConcurrentHashMap doesn’t throw a ConcurrentModificationException if one thread tries to modify it while another is iterating over it.
* ConcurrentHashMap uses multitude of locks.

SynchronizedHashMap

* Synchronization at Object level.
* Every read/write operation needs to acquire lock.
* Locking the entire collection is a performance overhead.
* This essentially gives access to only one thread to the entire map & blocks all the other threads.
* It may cause contention.
* SynchronizedHashMap returns Iterator, which fails-fast on concurrent modification.

Now let’s take a look at code
1. Create class CrunchifyConcurrentHashMapVsSynchronizedHashMap.java
2. Create object for each HashMap, SynchronizedMap and ConcurrentHashMap
3. Add and retrieve 500k entries from Map
4. Measure start and end time and display time in milliseconds
5. We will use ExecutorService to run 5 threads in parallel
- CrunchifyConcurrentHashMapVsSynchronizedMap.java

view plaincopy to clipboardprint?
package crunchify.com.tutorials;  
  
import java.util.Collections;  
import java.util.HashMap;  
import java.util.Hashtable;  
import java.util.Map;  
import java.util.concurrent.ConcurrentHashMap;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.TimeUnit;  
  
/** 
* @author Crunchify.com 
* 
*/  
  
public class CrunchifyConcurrentHashMapVsSynchronizedMap {  
  
    public final static int THREAD_POOL_SIZE = 5;  
  
    public static Map crunchifyHashTableObject = null;  
    public static Map crunchifySynchronizedMapObject = null;  
    public static Map crunchifyConcurrentHashMapObject = null;  
  
    public static void main(String[] args) throws InterruptedException {  
  
        // Test with Hashtable Object  
        crunchifyHashTableObject = new Hashtable();  
        crunchifyPerformTest(crunchifyHashTableObject);  
  
        // Test with synchronizedMap Object  
        crunchifySynchronizedMapObject = Collections.synchronizedMap(new HashMap());  
        crunchifyPerformTest(crunchifySynchronizedMapObject);  
  
        // Test with ConcurrentHashMap Object  
        crunchifyConcurrentHashMapObject = new ConcurrentHashMap();  
        crunchifyPerformTest(crunchifyConcurrentHashMapObject);  
  
    }  
  
    public static void crunchifyPerformTest(final Map crunchifyThreads) throws InterruptedException {  
  
        System.out.println("Test started for: " + crunchifyThreads.getClass());  
        long averageTime = 0;  
        for (int i = 0; i < 5; i++) {  
  
            long startTime = System.nanoTime();  
            ExecutorService crunchifyExServer = Executors.newFixedThreadPool(THREAD_POOL_SIZE);  
  
            for (int j = 0; j < THREAD_POOL_SIZE; j++) {  
                crunchifyExServer.execute(new Runnable() {  
                    @SuppressWarnings("unused")  
                    @Override  
                    public void run() {  
  
                        for (int i = 0; i < 500000; i++) {  
                            Integer crunchifyRandomNumber = (int) Math.ceil(Math.random() * 550000);  
  
                            // Retrieve value. We are not using it anywhere  
                            Integer crunchifyValue = crunchifyThreads.get(String.valueOf(crunchifyRandomNumber));  
  
                            // Put value  
                            crunchifyThreads.put(String.valueOf(crunchifyRandomNumber), crunchifyRandomNumber);  
                        }  
                    }  
                });  
            }  
  
            // Make sure executor stops  
            crunchifyExServer.shutdown();  
  
            // Blocks until all tasks have completed execution after a shutdown request  
            crunchifyExServer.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);  
  
            long entTime = System.nanoTime();  
            long totalTime = (entTime - startTime) / 1000000L;  
            averageTime += totalTime;  
            System.out.println("2500K entried added/retrieved in " + totalTime + " ms");  
        }  
        System.out.println("For " + crunchifyThreads.getClass() + " the average time is " + averageTime / 5 + " ms\n");  
    }  
}  

One possible execution result:

Test started for: class java.util.Hashtable
500K entried added/retrieved in 1432 ms
500K entried added/retrieved in 1425 ms
500K entried added/retrieved in 1373 ms
500K entried added/retrieved in 1369 ms
500K entried added/retrieved in 1438 ms
For class java.util.Hashtable the average time 1407 ms

Test started for: class java.util.Collections$SynchronizedMap
500K entried added/retrieved in 1431 ms
500K entried added/retrieved in 1460 ms
500K entried added/retrieved in 1387 ms
500K entried added/retrieved in 1456 ms
500K entried added/retrieved in 1406 ms
For class java.util.Collections$SynchronizedMap the average time 1428 ms

Test started for: class java.util.concurrent.ConcurrentHashMap
500K entried added/retrieved in 413 ms
500K entried added/retrieved in 351 ms
500K entried added/retrieved in 427 ms
500K entried added/retrieved in 337 ms
500K entried added/retrieved in 339 ms
For class java.util.concurrent.ConcurrentHashMap the average time 373 ms <== Much faster

This message was edited 10 times. Last update was at 30/11/2016 20:59:38

程式扎記

標籤

2016年11月30日星期三

[Linux 常見問題] Iptables Open VNC Port To Allow Incoming VNC Connections

[ Java 文章收集 ] HashMap Vs. ConcurrentHashMap Vs. SynchronizedMap – How a HashMap can be Synchronized

[Git 常見問題] error: The following untracked working tree files would be overwritten by merge

檢舉濫用情形

學習筆記

標籤

2016年11月30日 星期三