java thread Wait & Notify example

WaitNotifyTest .java
------------------------------------------------------



package waitnotifytest;

public class WaitNotifyTest {

    public static void main(String[] args) {
        Message msg = new Message("process it");
        Waiter waiter = new Waiter(msg);
        new Thread(waiter,"waiter_1").start();
       
        Waiter waiter1 = new Waiter(msg);
        new Thread(waiter1, "waiter2").start();
       
        Notifier notifier = new Notifier(msg);
        new Thread(notifier, "notifier").start();
        System.out.println("All the threads are started");
    }

}







Waiter.java
----------------------------------------------------------------------

package waitnotifytest;

import java.util.Date;

public class Waiter implements Runnable{
   
    private Message msg;
   
    public Waiter(Message m){
        this.msg=m;
    }

    @Override
    public void run() {
        String thread_name = Thread.currentThread().getName();
       
        synchronized (msg) {
            try{
                System.out.println(thread_name+" waiting to get notified at time:"+System.currentTimeMillis()+ " min="+new Date().getMinutes()+" sec=" + new Date().getSeconds());
                msg.wait();
                System.out.println("--wait()");
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(thread_name+" after wait at time:"+System.currentTimeMillis()+ " min="+new Date().getMinutes()+" sec="  + new Date().getSeconds());
            //process the message now
            System.out.println(thread_name+" processed: "+msg.getMsg());
        }
    }

}








Notifier.java
------------------------------------------------------

package waitnotifytest;

public class Notifier implements Runnable {

    private Message msg;
   
    public Notifier(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        String thread_name = Thread.currentThread().getName();
        System.out.println(thread_name+" started");
        try {
            Thread.sleep(1000);
            synchronized (msg) {
                msg.setMsg("Notifier thread_name=" + thread_name+" Notifier work done");
//                msg.notify();
                 msg.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       
    }

}


Message.java
-----------------------------------------------------------------------------------
package waitnotifytest;

public class Message {
    private String msg;
   
    public Message(String str){
        this.msg=str;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String str) {
        this.msg=str;
    }

}



###############output#################
All the threads are started
notifier started
waiter_1 waiting to get notified at time:1490077406336 min=23 sec=26
waiter2 waiting to get notified at time:1490077406342 min=23 sec=26
--wait()
waiter2 after wait at time:1490077407336 min=23 sec=27
waiter2 processed: Notifier thread_name=notifier Notifier work done
--wait()
waiter_1 after wait at time:1490077407336 min=23 sec=27
waiter_1 processed: Notifier thread_name=notifier Notifier work done

java thread & synchronized example

package threadjoinexample;

import java.util.logging.Level;
import java.util.logging.Logger;

public class ThreadJoinExample {

    public static void main(String[] args) {
        Table mTable = new Table();//only one object 
       
        Thread t1 = new Thread(new MyRunnable(mTable), "1st");
        Thread t2 = new Thread(new MyRunnable(mTable), "2nd");
        Thread t3 = new Thread(new MyRunnable(mTable), "3rd");

        t1.start();

        //start second thread after waiting for 2 seconds or if it's dead
//        try {
////            t1.join(2000);
//            System.out.println("1st try");
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        try {
            t1.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(ThreadJoinExample.class.getName()).log(Level.SEVERE, null, ex);
        }
        t2.start();

        //checks if this thread is alive
        System.out.println(t1.getName() + "=, isAlive = " + t1.isAlive());

        //start third thread only when first thread is dead
//        try {
////            t1.join();
//            System.out.println("2nd block  try="+t1.getName());
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        try {
            t2.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(ThreadJoinExample.class.getName()).log(Level.SEVERE, null, ex);
        }
        t3.start();
       
        try {
            t3.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(ThreadJoinExample.class.getName()).log(Level.SEVERE, null, ex);
        }

        //let all threads finish execution before finishing main thread
//        try {
//
////            t1.join();
//
//            System.out.print(t2.getName());
//            //checks if this thread is alive
//            System.out.println(", t2 isAlive = " + t2.isAlive());
//
////            t2.join();
////            t3.join();
//        } catch (InterruptedException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }

        System.out.println("All threads are dead, exiting main thread");
    }

}

class MyRunnable implements Runnable {
    Table t;
   
    MyRunnable(Table t) {
        this.t = t;
    }

    synchronized void test() {
        for (int i = 1; i <= 5; i++) {
            try {
                Thread.sleep(500);
            } catch (Exception e) {
                System.out.println(e);
            }
            System.out.println(i*100 + " " + Thread.currentThread().getName());
        }
    }

    @Override
    public void run() {
        System.out.println("--Thread started:::" + Thread.currentThread().getName());
        t.printTable(100);
//        test();
//        try {
//            Thread.sleep(4000);
//            System.out.println("run() 4s after=" + Thread.currentThread().getName());
//
//            test();
//
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println("!--Thread ended:::" + Thread.currentThread().getName()+"\n\n");
    }

}

class Table {

    synchronized void printTable(int n) {//synchronized method 
        for (int i = 1; i <= 5; i++) {
            try {
                Thread.sleep(500);
            } catch (Exception e) {
                System.out.println(e);
            }
            System.out.println(i*100 + " " + Thread.currentThread().getName());
        }

    }
}

java thread join example

package threadjoinexample;

import java.util.logging.Level;
import java.util.logging.Logger;

public class ThreadJoinExample {

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable(), "1st");
        Thread t2 = new Thread(new MyRunnable(), "2nd");
        Thread t3 = new Thread(new MyRunnable(), "3rd");

//        try {
//            t2.join();
//        } catch (InterruptedException ex) {
//            Logger.getLogger(ThreadJoinExample.class.getName()).log(Level.SEVERE, null, ex);
//        }

        t1.start();

        //start second thread after waiting for 2 seconds or if it's dead
//        try {
////            t1.join(2000);
//            System.out.println("1st try");
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        try {
            t1.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(ThreadJoinExample.class.getName()).log(Level.SEVERE, null, ex);
        }
        t2.start();
       
       
            //checks if this thread is alive
      System.out.println(t1.getName()+"=, isAlive = " + t1.isAlive());

        //start third thread only when first thread is dead
//        try {
////            t1.join();
//            System.out.println("2nd block  try="+t1.getName());
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        try {
            t2.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(ThreadJoinExample.class.getName()).log(Level.SEVERE, null, ex);
        }
        t3.start();

        //let all threads finish execution before finishing main thread
        try {
           
           
            t1.join();
           
            System.out.print(t2.getName());
            //checks if this thread is alive
      System.out.println(", t2 isAlive = " + t2.isAlive());
           
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("All threads are dead, exiting main thread");
    }

}

class MyRunnable implements Runnable {

    @Override
    public synchronized void run() {
        System.out.println("--Thread started:::" + Thread.currentThread().getName());
        try {
            Thread.sleep(4000);
            System.out.println("run() 4s after=" + Thread.currentThread().getName());

            for (int i = 1; i <= 5; i++) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    System.out.println(e);
                }
                System.out.println(i + " " + Thread.currentThread().getName());
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("--Thread ended:::" + Thread.currentThread().getName());
    }

}








----------------------------------
output:
--Thread started:::1st
run() 4s after=1st
1 1st
2 1st
3 1st
4 1st
5 1st
--Thread ended:::1st
1st=, isAlive = false
--Thread started:::2nd
run() 4s after=2nd
1 2nd
2 2nd
3 2nd
4 2nd
5 2nd
--Thread ended:::2nd
2nd, t2 isAlive = false
--Thread started:::3rd
run() 4s after=3rd
1 3rd
2 3rd
3 3rd
4 3rd
5 3rd
--Thread ended:::3rd
All threads are dead, exiting main thread

android custom camera with surface view

Download: http://www.mediafire.com/file/m99on6dc2d42dss/SurfaceviewExample4.zip

package com.javacodegeeks.androidsurfaceviewexample;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import android.app.Activity;
import android.hardware.Camera;
import android.hardware.Camera.PictureCallback;
import android.hardware.Camera.ShutterCallback;
import android.os.Bundle;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;

public class AndroidSurfaceviewExample extends Activity implements SurfaceHolder.Callback {


    Camera camera;
    SurfaceView surfaceView;
    SurfaceHolder surfaceHolder;

    PictureCallback jpegCallback;
    TextView capture;
    LinearLayout llcontainer;

    /**     * Called when the activity is first created.     */    @Override    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        surfaceView = (SurfaceView) findViewById(R.id.surfaceView);
        capture = (TextView) findViewById(R.id.capture);
        llcontainer= (LinearLayout) findViewById(R.id.container);


        surfaceHolder = surfaceView.getHolder();

        // Install a SurfaceHolder.Callback so we get notified when the        // underlying surface is created and destroyed.        surfaceHolder.addCallback(this);

        // deprecated setting, but required on Android versions prior to 3.0        surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);


        capture.setOnClickListener(new View.OnClickListener() {
            @Override            public void onClick(View view) {
                try {
                    captureImage(view);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });

        llcontainer.setOnClickListener(new View.OnClickListener() {
            @Override            public void onClick(View view) {
                try {
                    captureImage(view);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });

        jpegCallback = new PictureCallback() {
            public void onPictureTaken(byte[] data, Camera camera) {
                FileOutputStream outStream = null;
                try {
                    outStream = new FileOutputStream(String.format("/sdcard/%d.jpg", System.currentTimeMillis()) );
                    outStream.write(data);
                    outStream.close();
                    Log.d("Log", "onPictureTaken - wrote bytes: " + data.length);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                }
                Toast.makeText(getApplicationContext(), "Picture Saved", Toast.LENGTH_SHORT).show();
                refreshCamera();
            }
        };
    }

    public void captureImage(View v) throws IOException {
        //take the picture        camera.takePicture(null, null, jpegCallback);
    }

    public void refreshCamera() {
        if (surfaceHolder.getSurface() == null) {
            // preview surface does not exist            return;
        }

        // stop preview before making changes        try {
            camera.stopPreview();
        } catch (Exception e) {
            // ignore: tried to stop a non-existent preview        }

        // set preview size and make any resize, rotate or        // reformatting changes here        // start preview with new settings        try {
            camera.setPreviewDisplay(surfaceHolder);
            camera.startPreview();
        } catch (Exception e) {

        }
    }

    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
        // Now that the size is known, set up the camera parameters and begin        // the preview.        refreshCamera();
    }

    public void surfaceCreated(SurfaceHolder holder) {
        try {
            // open the camera            camera = Camera.open();

        } catch (RuntimeException e) {
            // check for exceptions            System.err.println(e);
            return;
        }
        Camera.Parameters param;
        param = camera.getParameters();





        param.setRotation(90); //set rotation to save the picture
        camera.setDisplayOrientation(90); //set the rotation for preview camera


        // modify parameter        param.setPreviewSize(352, 288);
        camera.setParameters(param);
        try {
            // The Surface has been created, now tell the camera where to draw            // the preview.            camera.setPreviewDisplay(surfaceHolder);
            camera.startPreview();
        } catch (Exception e) {
            // check for exceptions            System.err.println(e);
            return;
        }
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        // stop preview and release camera        camera.stopPreview();
        camera.release();
        camera = null;
    }

}

android double tap, shake mobile , vibrate

Download: http://www.mediafire.com/file/r09xh97laf7cmt3/double_tap_shake_vibrate.zip