There is a nice post about it on mishadoff&#39;s blog [**here**](http://mishadoff.github.io/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/).

The class is officially undocumented though.

Regarding the *putOrdered* methods.. 

You can call this method to set the volatile field without using a volatile store.. If you execute a volatile store, you basically have a store memory barrier which ensures that all store instruction prior the barrier, happen before barrier and that memory is visible by ensuring the data is propagated to the cache sub-system.. So when you have the volatile store you must wait for the store buffer to drain.. With *putOrdered* thread executing will not wait for the store buffer to drain and this can improve performance.. However as a consequence stored value will not be visible to other threads immediately..

If you have a look on *AtomicLong* (or other Atomic classes) there is a *lazySet* method that actually executes putOrderedLong. The javadoc on this method is:

&gt; Eventually sets to the given value.


What possible reasons can [Sidekiq][1] prevent from processing jobs in the queue? The queue is full. The log file `sidekiq.log` indicates no activity at all. Thus the queue is full but the log is empty, and Sidekiq does not seem to process items. There seem to no worker processing jobs. Restarting Redis or flush it with [FLUSHALL][2] or [FLUSHDB][3] as no effect. Sidekiq has been started with 

&gt; bundle exec sidekiq -L log/sidekiq.log

and produces the following log file:

    2013-05-30..Booting Sidekiq 2.12.0 using redis://localhost:6379/0 with options {}
    2013-05-30..Running in ruby 1.9.3p374 (2013-01-15 revision 38858) [i686-linux]
    2013-05-30..See LICENSE and the LGPL-3.0 for licensing details.
    2013-05-30..Starting processing, hit Ctrl-C to stop

How can you find out what went wrong? Are there any hidden log files?


  [1]: https://github.com/mperham/sidekiq
  [2]: http://redis.io/commands/flushall
  [3]: http://redis.io/commands/flushdb

Sidekiq not processing queue

I am trying to save data across orientation changes. As demonstrated in the code below, I use `onSaveInstanceState()` and `onRestoreInstanceState()`. I try to get the saved value and I check if it is the correct value in `onRestoreInstanceState()`. But when I try to use the new value in `onCreate()`, I don&#39;t have the new value but the old one. 

    protected void onSaveInstanceState(Bundle outState) {
    		super.onSaveInstanceState(outState);
    		outState.putString(&quot;TEXT&quot;, user);
    
    	}
	protected void onRestoreInstanceState(Bundle savedInstanceState) {
		super.onRestoreInstanceState(savedInstanceState);
		savedUser = savedInstanceState.getString(&quot;TEXT&quot;);
		Log.d(&quot;enregistred value&quot;, savedUser);

	}



    public void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		
    		int display_mode = getResources().getConfiguration().orientation;
    
    		if (display_mode == 1) {
    
    			setContentView(R.layout.main_grid);
    			mGrid = (GridView) findViewById(R.id.gridview);
    			mGrid.setColumnWidth(95);
    			mGrid.setVisibility(0x00000000);
    			// mGrid.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION);
    
    		} else {
    			setContentView(R.layout.main_grid_land);
    			mGrid = (GridView) findViewById(R.id.gridview);
    			mGrid.setColumnWidth(95);
    			Log.d(&quot;Mode&quot;, &quot;land&quot;);
    			// mGrid.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION);
    
    		}
    		Log.d(&quot;savedUser&quot;, savedUser);
    		if (savedUser.equals(&quot;admin&quot;)) { //value 0
    			adapter.setApps(appManager.getApplications());
    		} else if (savedUser.equals(&quot;prof&quot;)) { //value 1
    			adapter.setApps(appManager.getTeacherApplications());
    		} else {// default value
    			appManager = new ApplicationManager(this, getPackageManager());
    			appManager.loadApplications(true);
    			bindApplications();
    	    }
    }



How to use onSaveInstanceState() and onRestoreInstanceState()?

Does anyone know of any comprehensive documentation for `sun.misc.Unsafe`?

I&#39;m looking for documentation on `Unsafe.putOrderedInt()`. [This][1] was all I was able to find.

```none
public native  void putOrderedInt(Object o,
    long offset,
    int x)

     Ordered/Lazy version of #putIntVolatile(Object, long, int) 
```

Does anyone know of a better source?

[1]: http://www.docjar.com/docs/api/sun/misc/Unsafe.html#putOrderedInt(Object,%20long,%20int)

Where is sun.misc.Unsafe documented?

Does anyone know of any comprehensive documentation for <code>sun.misc.Unsafe</code>?
I'm looking for documentation on <code>Unsafe.putOrderedInt()</code>. <a href="http://www.docjar.com/docs/api/sun/misc/Unsafe.html#putOrderedInt(Object,%20long,%20int)" target="_blank" rel="noopener noreferrer">This</a> was all I was able to find.
<pre><code class="hljs language-java">public native void putOrderedInt(Object o,
 long offset,
 int x)

 Ordered/Lazy version of #putIntVolatile(Object, long, int) 
</code></pre>
Does anyone know of a better source?

Question
========

I&#39;m porting a C application into C#. The C app calls lots of functions from a 3rd-party DLL, so I wrote P/Invoke wrappers for these functions in C#. Some of these C functions allocate data which I have to use in the C# app, so I used `IntPtr`&#39;s, [`Marshal.PtrToStructure`][1] and [`Marshal.Copy`][2] to copy the native data (arrays and structures) into managed variables. 

Unfortunately, the C# app proved to be much slower than the C version. A quick performance analysis showed that the above mentioned marshaling-based data copying is the bottleneck. **I&#39;m considering to speed up the C# code by rewriting it to use pointers instead.** Since I don&#39;t have experience with unsafe code and pointers in C#, I need expert opinion regarding the following **questions**:

1. What are the drawbacks of using `unsafe` code and pointers instead of `IntPtr` and `Marshal`ing? For example, is it more unsafe (pun intended) in any way? People seem to prefer marshaling, but I don&#39;t know why.
2. Is using pointers for P/Invoking really faster than using marshaling? How much speedup can be expected approximately? I couldn&#39;t find any benchmark tests for this.

Example code
============

To make the situation more clear, I hacked together a small example code (the real code is much more complex). I hope this example shows what I mean when I&#39;m talking about &quot;unsafe code and pointers&quot; vs. &quot;IntPtr and Marshal&quot;.

C library (DLL)
---------------

MyLib.h

    #ifndef _MY_LIB_H_
    #define _MY_LIB_H_
    
    struct MyData 
    {
      int length;
      unsigned char* bytes;
    };
    
    __declspec(dllexport) void CreateMyData(struct MyData** myData, int length);
    __declspec(dllexport) void DestroyMyData(struct MyData* myData);
    
    #endif // _MY_LIB_H_

MyLib.c

    #include &lt;stdlib.h&gt;
    #include &quot;MyLib.h&quot;
    
    void CreateMyData(struct MyData** myData, int length)
    {
      int i;
    
      *myData = (struct MyData*)malloc(sizeof(struct MyData));
      if (*myData != NULL)
      {
        (*myData)-&gt;length = length;
        (*myData)-&gt;bytes = (unsigned char*)malloc(length * sizeof(char));
        if ((*myData)-&gt;bytes != NULL)
          for (i = 0; i &lt; length; ++i)
            (*myData)-&gt;bytes[i] = (unsigned char)(i % 256);
      }
    }
    
    void DestroyMyData(struct MyData* myData)
    {
      if (myData != NULL)
      {
        if (myData-&gt;bytes != NULL)
          free(myData-&gt;bytes);
        free(myData);
      }
    }

C application
-------------

Main.c

    #include &lt;stdio.h&gt;
    #include &quot;MyLib.h&quot;
    
    void main()
    {
      struct MyData* myData = NULL;
      int length = 100 * 1024 * 1024;
    
      printf(&quot;=== C++ test ===\n&quot;);
      CreateMyData(&amp;myData, length);
      if (myData != NULL)
      {
        printf(&quot;Length: %d\n&quot;, myData-&gt;length);
        if (myData-&gt;bytes != NULL)
          printf(&quot;First: %d, last: %d\n&quot;, myData-&gt;bytes[0], myData-&gt;bytes[myData-&gt;length - 1]);
        else
          printf(&quot;myData-&gt;bytes is NULL&quot;);
      }
      else
        printf(&quot;myData is NULL\n&quot;);
      DestroyMyData(myData);
      getchar();
    }

C# application, which uses `IntPtr` and `Marshal`
-------------------------------------------------

Program.cs

    using System;
    using System.Runtime.InteropServices;
    
    public static class Program
    {
      [StructLayout(LayoutKind.Sequential)]
      private struct MyData
      {
        public int Length;
        public IntPtr Bytes;
      }
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private static extern void CreateMyData(out IntPtr myData, int length);
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private static extern void DestroyMyData(IntPtr myData);
    
      public static void Main()
      {
        Console.WriteLine(&quot;=== C# test, using IntPtr and Marshal ===&quot;);
        int length = 100 * 1024 * 1024;
        IntPtr myData1;
        CreateMyData(out myData1, length);
        if (myData1 != IntPtr.Zero)
        {
          MyData myData2 = (MyData)Marshal.PtrToStructure(myData1, typeof(MyData));
          Console.WriteLine(&quot;Length: {0}&quot;, myData2.Length);
          if (myData2.Bytes != IntPtr.Zero)
          {
            byte[] bytes = new byte[myData2.Length];
            Marshal.Copy(myData2.Bytes, bytes, 0, myData2.Length);
            Console.WriteLine(&quot;First: {0}, last: {1}&quot;, bytes[0], bytes[myData2.Length - 1]);
          }
          else
            Console.WriteLine(&quot;myData.Bytes is IntPtr.Zero&quot;);
        }
        else
          Console.WriteLine(&quot;myData is IntPtr.Zero&quot;);
        DestroyMyData(myData1);
        Console.ReadKey(true);
      }
    }

C# application, which uses `unsafe` code and pointers
-----------------------------------------------------

Program.cs

    using System;
    using System.Runtime.InteropServices;
    
    public static class Program
    {
      [StructLayout(LayoutKind.Sequential)]
      private unsafe struct MyData
      {
        public int Length;
        public byte* Bytes;
      }
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private unsafe static extern void CreateMyData(out MyData* myData, int length);
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private unsafe static extern void DestroyMyData(MyData* myData);
    
      public unsafe static void Main()
      {
        Console.WriteLine(&quot;=== C# test, using unsafe code ===&quot;);
        int length = 100 * 1024 * 1024;
        MyData* myData;
        CreateMyData(out myData, length);
        if (myData != null)
        {
          Console.WriteLine(&quot;Length: {0}&quot;, myData-&gt;Length);
          if (myData-&gt;Bytes != null)
            Console.WriteLine(&quot;First: {0}, last: {1}&quot;, myData-&gt;Bytes[0], myData-&gt;Bytes[myData-&gt;Length - 1]);
          else
            Console.WriteLine(&quot;myData.Bytes is null&quot;);
        }
        else
          Console.WriteLine(&quot;myData is null&quot;);
        DestroyMyData(myData);
        Console.ReadKey(true);
      }
    }


  [1]: http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.ptrtostructure.aspx
  [2]: http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.copy.aspx







C# performance - Using unsafe pointers instead of IntPtr and Marshal

In Java 8 three memory barrier instructions were added to `Unsafe` class ([source][1]):

    /**
     * Ensures lack of reordering of loads before the fence
     * with loads or stores after the fence.
     */
    void loadFence();

    /**
     * Ensures lack of reordering of stores before the fence
     * with loads or stores after the fence.
     */
    void storeFence();

    /**
     * Ensures lack of reordering of loads or stores before the fence
     * with loads or stores after the fence.
     */
    void fullFence();

If we define memory barrier with the following way (which I consider more or less easy to understand):

&gt; Consider X and Y to be operation types/classes that are subject for reordering,
&gt;
&gt; **`X_YFence()` is a memory barrier instruction that ensures that all operations of type X before the barrier completed before any operation of type Y after the barrier is started.**

We can now &quot;map&quot; barrier names from `Unsafe` to this terminology:

* `loadFence()` becomes `load_loadstoreFence()`;
* `storeFence()` becomes `store_loadStoreFence()`;
* `fullFence()` becomes `loadstore_loadstoreFence()`;

Finally, **my question is** - why don&#39;t we have `load_storeFence()`, `store_loadFence()`, `store_storeFence()` and `load_loadFence()`?

My guess would be - they are not really neccesary, but I do not understand why at the moment. So, I&#39;d like to know reasons for not adding them. Guesses about that are welcome too (hope this doesn&#39;t cause this question to be offtopic as opinion-based, though).

Thanks in advance.

  [1]: http://openjdk.java.net/jeps/171

Java 8 Unsafe: xxxFence() instructions

I never needed to use unsafe in the past, but now I need it to work with a pointer manipulating a bitmap.

I couldn&#39;t find any documentation that indicates otherwise, but I would like to understand better how unsafe works and if it makes any difference to use it inside or outside a loop.

Is it better to do:

    unsafe
    {
    	for (int x = 0; x &lt; maxX; x++)
    	{
    		for (int y = 0; y &lt; maxY; y++)
    		{			
    			//Unsafe pointer operations here.
    		}
    	}
    }

Or to do?:
	

    for (int x = 0; x &lt; maxX; x++)
    {
    	for (int y = 0; y &lt; maxY; y++)
    	{	
    		unsafe
    		{		
    			//Unsafe pointer operations here.
    		}
    	}
    }

Does it make any difference to use unsafe inside or outside a loop?

What is the implementation for this function:

    fn unbox&lt;T&gt;(value: Box&lt;T&gt;) -&gt; T {
        // ???
    }

The only function in the documentation that looks like what I want is `Box::into_raw`. The following will type check:

    fn unbox&lt;T&gt;(value: Box&lt;T&gt;) -&gt; T {
        *value.into_raw()
    }

This gives the error `error[E0133]: dereference of raw pointer requires unsafe function or block`. Wrapping it in an `unsafe { ... }` block fixes it.

    fn unbox&lt;T&gt;(value: Box&lt;T&gt;) -&gt; T {
        unsafe { *value.into_raw() }
    }

Is this the correct implementation? If so, why is it unsafe? What does it mean?

Perhaps this question shows my general uncertainty of how `Box`s actually work.

How do I get an owned value out of a `Box`?

    Loop.times(5, () -&gt; {
       System.out.println(&quot;looping&quot;);
    });

Which of these would it effectively compile to?

    for(int i = 0; i &lt; 5; i++)
        System.out.println(&quot;looping&quot;);

or something like

    new CallableInterfaceImpl(){
        public void call(){
          for(int i = 0; i &lt; 5; i++)
              System.out.println(&quot;looping&quot;);
        }
    }.call();

So would it replace (kind of inline), or actually create an anonymous class?


How will Java lambda functions be compiled?

I saw the following code in [this commit][2] for [MongoDB&#39;s Java Connection driver][3], and it appears at first to be a joke of some sort. What does the following code do?

    if (!((_ok) ? true : (Math.random() &gt; 0.1))) {
        return res;
    }

(EDIT: the code [has been updated since][1] posting this question)

  [1]: https://github.com/mongodb/mongo-java-driver/commit/8e02cd006d79acd1d0ae6604c2ee7537b250c044#diff-08d4a794472cb22d6bf2c4bb0615aa49L212
  [2]: https://github.com/mongodb/mongo-java-driver/blob/1d2e6faa80aeb5287a26d0348f18f4b51d566759/src/main/com/mongodb/ConnectionStatus.java#L213
  [3]: https://github.com/mongodb/mongo-java-driver


Why does the MongoDB Java driver use a random number generator in a conditional?

    class Test {
        public static void main(String arg[]) {    
            System.out.println(&quot;**MAIN METHOD&quot;);
            System.out.println(Mno.VAL); // SOP(9090);
            System.out.println(Mno.VAL + 100); // SOP(9190);
        }

    }
    
    class Mno {
        final static int VAL = 9090;
        static {
            System.out.println(&quot;**STATIC BLOCK OF Mno\t: &quot; + VAL);
        }
    }

I know that a `static` block executed when class loaded. But in this case the instance variable inside class `Mno` is `final`, because of that the `static` block is not executing. 

Why is that so? And if I would remove the `final`, would it work fine? 

Which memory will be allocated first, the `static final` variable or the `static` block? 

If due to the `final` access modifier the class does not get loaded, then how can the variable get memory?

Static block in Java not executed

Lambda expressions are being added in Java 8. I want to understand why this is important. What does it mean to a Java programmer who is yet to be exposed to functional programming idioms? Does it mean I can write code that performs better or scales massively or does it only make the code less verbose. Or all of it.

Java Lambda expressions

I am getting a parsing exception while I am trying the following code:

        String date=&quot;Sat Jun 01 12:53:10 IST 2013&quot;;
        SimpleDateFormat sdf=new SimpleDateFormat(&quot;MMM d, yyyy HH:mm:ss&quot;);
        Date currentdate;
        currentdate=sdf.parse(date);
        System.out.println(currentdate);

Exception: 

&gt;Exception in thread &quot;main&quot; java.text.ParseException: Unparseable date: &quot;Sat Jun 01 12:53:10 IST 2013&quot;
&gt;at com.ibm.icu.text.DateFormat.parse(DateFormat.java:510)

Input: `Sat Jun 01 12:53:10 IST 2013`

Expected output: `Jun 01,2013 12:53:10`

How to solve this?


Content Type	Original Author	Original Content on Stackoverflow
Question	James Raitsev	View Question on Stackoverflow
Solution 1 - Unsafe	mwerschy	View Answer on Stackoverflow
Solution 2 - Unsafe	Ivan Senic	View Answer on Stackoverflow

Where is sun.misc.Unsafe documented?

Unsafe Problem Overview

Unsafe Solutions

Solution 1 - Unsafe

Solution 2 - Unsafe

How to use onSaveInstanceState() and onRestoreInstanceState()?

Sidekiq not processing queue

Attributions