HashMap Vs ConcurrentHashMap : Java 

HashMap vs ConcurrentHashMap

1.  Thread -Safe : 

     ConcurrentHashMap is thread-safe that is the code can be accessed by single thread at a time .    
     while HashMap is not thread-safe .

2.  Synchronization Method :

    HashMap can be synchronized by using    
    synchronizedMap(HashMap)  method .  By using this  

    method we get a HashMap object which is equivalent 
    to the HashTable object . So every modification  is performed    
    on  Map is locked on Map object.

import java.util.*;

public class HashMapSynchronization {
    public static void main(String[] args) {
        // create map
        Map<String,String> map = new HashMap<String,String>();
        
        // populate the map
        map.put("1","ALIVE ");
        map.put("2","IS");
        map.put("3","AWESOME");
        
        // create a synchronized map
        Map<String,String> syncMap = Collections.synchronizedMap(map);
        
        System.out.println("Synchronized map :"+syncMap);
    }
}

   ConcurrentHashMap synchronizes or locks on the certain portion of the Map . To optimize
   the performance of ConcurrentHashMap , Map is divided into different partitions depending
   upon the Concurrency level . So that we do not need to synchronize the whole Map Object.


3.  Null Key


     ConcurrentHashMap does not allow NULL values . So the key can not be null in
     ConcurrentHashMap .While In HashMap there can only be one null key .

  
4.  Performance

     In multiple threaded environment HashMap is usually faster than ConcurrentHashMap . As   
     only single thread can access the certain portion of the Map and thus reducing the performance .
     While in HashMap any number of threads can access the code at the same time 

Continuous Deployment of Node.js Applications

Continuous deployment is...

No, let's take a step back and see what the differences are between continuous integration, continuous delivery and continuous deployment.

Continuous integration

Continuous integration is the process of merging development work with the master several times a day / constantly. This helps:

• catch issues early
• prevent "integration hell"

Most of the work here is done by automated tests.

Continuous delivery

Continuous delivery is the practice of delivery of code to an environment, whether it is a QA team or customers, so they can review it. After the changes get approved, they can land in production.

Continuous deployment

You can think of continuous deployment as the next step of continuous delivery, when each change that passes the automated tests are deployed to production automatically. Continuous deployment heavily relies on an infrastructure that automates and instruments the process of testing, integration and deployment of new features.

In this post we will go through these automation steps and cover most of the principles.

A simplified continuous deployment flow can look like this:

From Source Control to Production

Let's take a scenario, when a new feature is going to be developed and we want to see that in production. We will take a look at the life cycle of a code changeset from a commit till it goes live on our production environment.

It all starts with a commit

Every commit to the master should trigger a new build with tests - but when adding new functionalities, you do not want to see that half-ready feature in production.

Feature toggles

To solve this issue, continuous deployment setups usually go with feature toggles. Feature toggles are alternatives to feature branches and allows developers to release a version of a product that has unfinished features. These unfinished features are hidden by the toggles in production environment.

// dummy example to show a feature toggle using
// https://www.npmjs.org/package/feature-toggles

var featureToggles = require('feature-toggles');  
// define toggles
var toggles = {  
    foo: true, 
    bar: false
};

// load them into the module
featureToggles.load(toggles);

// check if a feature is enabled
if (featureToggles.isFeatureEnabled('foo')) {  
    // do something
}

When the feature is ready, the feature toggle can be removed.

Continuous deployment tools

But where does it trigger a new build? For this, you will need a continuous integration tool. There are a lot of them out there, including Jenkins,Travis, Codeship and Strider, which is written in Node.js. Jenkins and Strider are open-sourced, and can be operated on your own infrastructure.

Currently, we use Strider for our closed-source projects, and Travis for our open-source projects.

Each one of these tools support commit-hooks, so set one up! In this case your continuous integration tool does not need to poll git/svn regularly.

Build on commit

After the tool of your choice gets notified of a new commit, it starts a new build. A build can have a lot of steps, some of them can run in parallel. Speaking of Node.js applications, the following steps can occur:

• installing dependencies from NPM (public or private)
• run unit tests
• build assets, like css and javascript
• run integration/end-to-end tests
• creating artifacts (bundle the node_modules directory to it as well, so during deployment, you won't depend on NPM)

Automated tests

Automated tests are the most crucial parts of the build process.

Your modules must be covered by unit tests, and to check if everything works together you should have integration tests in place too. For these types of tests you can use mocha/tap/Jasmine, and an expectation library like chai.

Depending on whether you are creating an application with a frontend, or just an API, you can choose different tools for end-to-end testing.

If your application does not have a frontend, but is an API, you can usehippie or supertest for end-to-end tests.

When developing an application with frontend involved, you still have options to test the user interface as well. Protractor for AngularJS applications or Nightwatch. To make sure it works in every browser you support, run your end-to-end tests on a Selenium cluster. Or you can use services like Sauce Labs or Browserstack.

I cannot stress this enough: without good test coverage, Continuous Deployment can lead to serious production issues!

Creating artifacts

If all the tests pass then it is time to create an artifact from the build. An artifact should contain every single file that is necessary to run your application, so your production servers won't have to deal with building it again.

A simple tar filename.tar * can do the trick. Then make sure to place this file in a location where it is accessible for your production servers, so they can get it, like Amazon's S3, or any other storage.

Deploy

As we just created an artifact containing every assets that our application needs, we only need to do the following things:

• download the latest artifact
• unpack it to a new directory
• update the symlink, so it will point to the directory just created -
• restart the node application

It goes without saying: this process must be automated, and no manual steps should be involved. Tools like Ansible, Chef or Puppet can help.

Rollbacks

If things can go wrong, they will. Make sure to have a rollback script in place. The fastest and easiest way to do this is to set the symlink to a previous build and restart the node application

LinkedList vs ArrayList in Java

All the differences between LinkedList and ArrayList has there root on difference between Array and LinkedList data-structure. If you are familiar with Array and LinkedList data structure you will most likely derive following differences between them:

1) Since Array is an index based data-structure searching or getting element from Array with index is pretty fast. Array provides O(1) performance for get(index) method but remove is costly in ArrayList as you need to rearrange all elements. On the Other hand LinkedList doesn't provide Random or index based access and you need to iterate over linked list to retrieve any element which is of order O(n).

2) Insertions  are easy and fast in LinkedList as compared to ArrayList because there is no risk of resizing array

and copying content to new array if array gets full which makes adding into ArrayList of O(n) in worst case, while adding is O(1) operation in LinkedList in Java. ArrayList also needs to update its index if you insert something anywhere except at the end of array.

3) Removal is like insertions better in LinkedList than ArrayList.

4) LinkedList has more memory overhead than ArrayList because in ArrayList each index only holds actual object (data) but in case of LinkedList each node holds both data and address of next  and previous node.

When to use LinkedList and ArrayList in Java

As I said LinkedList is not as popular as ArrayList but still there are situation where a LinkedList is better choice than ArrayList in Java. Use LinkedList in Java if:

1) Your application can live without Random access. Because if you need nth element in LinkedList you need to first traverse up to nth element O(n) and than you get data from that node.

2) Your application is more insertion and deletion driver and you insert or remove more than retrieval. Since insertion or

removal doesn't involve resizing its much faster than ArrayList.

Good one..

Install and configure Jenkins on CentOS 6.4 - Part I

Jenkins is an opensource and most popular continuous integration tool written in Java. There are many plugins are available to make it more easier. It supports almost all version control systems. You can configure builts with various means like, triggered by a commit in a version control system, scheduling by cron-jobs, built after a specific built completes etc.. ect…

In this article I will show you how to install and configure Jenkins on CentOS 6.4.

Step – 1

To install and configure Jenkins on CentOS we have to first install JAVA on the machine. Below are the steps to install JAVA on CentOS.

yum install java-1.6.0-openjdk

Verify the java by issuing the below command

java -version

Now we will add Jenkins Repository to our machine.

wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat/jenkins.repo

rpm --import http://pkg.jenkins-ci.org/redhat/jenkins-ci.org.key

Now we will Install Jenkins

yum install jenkins

Add Jenkins to system boot

chkconfig jenkins on

Start Jenkins

service jenkins start

By default Jenkins will start on Port 8080. You can verify that with the below command.

netstat -tnlp | grep 8080

Go to your browser and type http://localhost:8080/. Now you should able to see the Jenkins dashboard like below image.

Step – 2

Now we will setup Authentication for Jenkins. By default Jenkins allows “Anyone can do anything.”. Here we will setup Matrix based security authentication. For this follow the below steps:

Click on Manage Jenkins > Configure Global Security > Jenkins Own User Database > Allow Users to Signup > Save

Step – 3

After saving the above step then follow the below step to create an user:

Click on Signup button (Top right corner of the dashboard) > Fill all the required information > click on SignUp (Below the Form)

Step – 3

Now we will restrict User Signup and add “Matrix based security authentication”. Please follow the below steps:

Click on Manage Jenkins > Configure Global Security > Jenkins Own User Database > Unchek “Allow Users to Signup” > Matrix-based security > Put the user Name @ “User/group to add:” text box > click on add > Check all the Check boxes > Save

Now onwards User “Tapas Mishra” can administrate Jenkins after login. Also you can add more user to the db by following the below

Step – 4

Click on Manage Jenkins > Manage Users > Create U

ser

s

After

thi

s follow the Step – 3 again to add previliage to the new user.

Add nodes and configure Jobs to Start a Built Process -- Part II

I have described in my previous article about Jenkins and how to install and configure user account on it. In this article I will describe about how to configure nodes on Jenkins. Nodes are the servers where we will deploy our applications. You can configure n number of Nodes in your Jenkins applications depending on the server capacity.

Before configuring a node we have to add there credential first. Like user name and password for the node if the node is passwordbased authentication enabled. Else you can add the user name and private key if the node is passwordless authentication enabled.

How to add credentials

Log in to your Jenkins account. Click on the credential tab as shown in the below image.

Now Click on “Add domain” as shown in the below image.

Provide a user friendly name and some description to it and press “OK”

Now Click on “Add Credentials” tab then provide your information as shown in the below image.

After completing the Credential entry in the Jenknins now we will add the Node.

How to add Node on Jenkins

Go to the main dashboard of Jenkins Click on “Manage Jenkins” > Click on “Manage Nodes” from the List.

You will find a Node named “Master” in the node list which is the Jenkins server itself.

To add a new node click on “New Node”. Enter the information and click on as shown in the below image.

Now enter all the information about your host as shown in the below Image. Click on the advance and modify your port number if you are using any different port for your SSH.

It will take some time to Lunch the new node and then you will able to see the information about the node in your Jenkins Dashboard. See the below image.

Jenkins - Part III

In my previous articles (Jenkins Part I and Jenkins Part II) I have already described how to install Jenkins, how to Setup User account on Jenkins, how to Configure Nodes on Jenkins. In this article we will see how to configure a job on Jenkins. Basically the job will deploy an application from Github on a configured node. We will configure a simple Job in this part. We will just clone a github repository in a node using Jenkins. But in our later articles we will discuss about critical deployments.

We will complete this in three steps.

• Install required Plugin
• Configure Job
• Build the Job and verify

Step 1 (Install required Plugin)

If we are using GIT as our Sour Code Management then we have to install plugin for it. The git plugin will help use to deploy the codes on a node. It’s very simple to configure. To install a plugin follow the steps as described below

Click on Manage Jenkins > Click on Manage Plugins > Click on Available Tab > Filter the Git Plugins > Chose the Git Plugin > Click on install without restart. > Chose Restart Jenkins when installation is complete option.

Step 2 (Configure Job)

Now we will create a Job for deploying an application on our previously configured server from github. To Create a new job Click on New Job > Give a Name to the Job > Choose “Build a free-style software project” option > Click on “Ok”

After getting the new window Check the option “Restrict where this project can be run“. You will get a text box to enter a node name where the build will be taken place (Setup a node following the steps in my previous article). Write the node name in my case it’s “www.linuxfunda.com“. If you will not check this option then Jenkins will clone your repository in Master itself.

Chose the Git Radio button from the “Source Code Management” section and write the Github Repository URL. In my case it’s “ https://github.com/tapasprivate/tapasprivate.git “.  I have described how to add Credentials in my previous article. Add the appropriate credential for the github account. Specify the branch name if you want any specific branch to clone else  it will clone “master” branch of the repository. There are also other advance options are available like git submodules which we will discuss in later articles.

Step 3 (Build the Job and Verify)

Now we have done with the configuration of the job. Save the Configuration and build the job. SSH to your node where you took the build. Go to the Workspace path and verify that your files are there from github. In my next article we will configure a job with shell script.

:)