If there are ten threads blocked on the condition variable, for example, `notify_one()` will unblock only one thread, while `notify_all()` will unblock them all. In your case, you&#39;ll want to use `notify_one()` so you don&#39;t wake up threads that don&#39;t have any work waiting for them.

Having the above error in your Android JNI app?  Read on...

Up front, I&#39;ll say that I&#39;ve already solved this, in my own way, but I feel something in the Android build system (perhaps regarding Eclipse) is broke, and I hope to save someone else hours of pain.  Perhaps others have come across this issue and can comment on what worked for them.

For a while, I&#39;ve had an Android project with some JNI code that I developed using the NDK.  Then, today, I changed something in the java code and then poof, I could no longer load my JNI library.  It failed with an exception like:

&gt; E/AndroidRuntime(  999): java.lang.UnsatisfiedLinkError: Couldn&#39;t load mylibrary: findLibrary returned null

I googled and tried everything (rebuilding, close and relaunch Eclipse, etc, etc)

What finally fixed my problem?  I physically uninstalled my app from the device before trying another run.  That&#39;s it.  After that, it worked.  What worked for you?


Android NDK java.lang.UnsatisfiedLinkError: findLibrary returned null

I&#39;m currently taking a Natural Language Processing course at my University and still confused with some basic concept. I get the definition of POS Tagging from the [Foundations of Statistical Natural Language Processing][1] book:

&gt; Tagging is the task of labeling (or tagging) each word in a sentence
with its appropriate part of speech. We decide whether each word is a
noun, verb, adjective, or whatever.

But I can&#39;t find a definition of Shallow Parsing in the book since it also describe shallow parsing as one of the utilities of POS Tagging. So I began to search the web and found no direct explanation of shallow parsing, but in [Wikipedia][2]:

&gt; Shallow parsing (also chunking, &quot;light parsing&quot;) is an analysis of a sentence which identifies the constituents (noun groups, verbs, verb groups, etc.), but does not specify their internal structure, nor their role in the main sentence.

I frankly don&#39;t see the difference, but it may be because of my English or just me not understanding simple basic concept. Can anyone please explain the difference between shallow parsing and POS Tagging? Is shallow parsing often also called Shallow Semantic Parsing?

Thanks before.


  [1]: http://www-nlp.stanford.edu/fsnlp/
  [2]: http://en.wikipedia.org/wiki/Shallow_parsing

What Is the Difference Between POS Tagging and Shallow Parsing?

Currently, I am implementing a multi-thread project using `std::thread` in C++11. I use `std::condition_variable` to synchronize threads. In detail, one consumer function calls `wait()` member function of `std::condition_variable` to wait for task from a global task queue, another producer function generates and puts tasks into the queue. But I do not know the difference between `notify_all()` and `notify_one()` member functions of `std::condition_variable`. Which function should I use in the producer function? Thanks!


What&#39;s the difference between notify_all() and notify_one() of std::condition_variable?

<p>Currently, I am implementing a multi-thread project using <code>std::thread</code> in C++11. I use <code>std::condition_variable</code> to synchronize threads. In detail, one consumer function calls <code>wait()</code> member function of <code>std::condition_variable</code> to wait for task from a global task queue, another producer function generates and puts tasks into the queue. But I do not know the difference between <code>notify_all()</code> and <code>notify_one()</code> member functions of <code>std::condition_variable</code>. Which function should I use in the producer function? Thanks!</p>


How do I define a preprocessor variable through CMake?

The equivalent code would be `#define foo`.

Define preprocessor macro through CMake?

Here is a simplification of what I&#39;m seeing when I try to use unique_ptr for pimpl.  I chose unique_ptr because I really want the class to own the pointer - I want the lifetimes of the pimpl pointer and the class to be the same.

Anyway, here is the header:

    #ifndef HELP
    #define HELP 1
    
    #include &lt;memory&gt;
    
    class Help
    {
    
    public:
    
      Help(int ii);
      ~Help() = default;
    
    private:
    
      class Impl;
      std::unique_ptr&lt;Impl&gt; _M_impl;
    };
    
    #endif // HELP

Here is the source:

    #include &quot;Help.h&quot;
    
    class Help::Impl
    {
    public:
      Impl(int ii)
      : _M_i{ii}
      { }
    
    private:
    
      int _M_i;
    };
    
    Help::Help(int ii)
    : _M_impl{new Help::Impl{ii}}
    { }

I could compile these into a library just fine.  But when I try to use it in a test program I get

    ed@bad-horse:~/ext_distribution$ ../bin/bin/g++ -std=c++0x -o test_help test_help.cpp Help.cpp
    In file included from /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/memory:86:0,
                     from Help.h:4,
                     from test_help.cpp:3:
    /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/unique_ptr.h: In instantiation of &#39;void std::default_delete&lt;_Tp&gt;::operator()(_Tp*) const [with _Tp = Help::Impl]&#39;:
    /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/unique_ptr.h:245:4:   required from &#39;void std::unique_ptr&lt;_Tp, _Dp&gt;::reset(std::unique_ptr&lt;_Tp, _Dp&gt;::pointer) [with _Tp = Help::Impl; _Dp = std::default_delete&lt;Help::Impl&gt;; std::unique_ptr&lt;_Tp, _Dp&gt;::pointer = Help::Impl*]&#39;
    /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/unique_ptr.h:169:32:   required from &#39;std::unique_ptr&lt;_Tp, _Dp&gt;::~unique_ptr() [with _Tp = Help::Impl; _Dp = std::default_delete&lt;Help::Impl&gt;]&#39;
    Help.h:6:7:   required from here
    /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/unique_ptr.h:63:14: error: invalid application of &#39;sizeof&#39; to incomplete type &#39;Help::Impl&#39;

This is a well known [safety feature][1].  I&#39;ve tried to follow.

My problem is that if I put Help::Impl declaration in a header it would seem to obviate any advantage of pimpl.  The class layout is visible to users.  The definition is hidden but I could have done that with the Help class and private members.  Also, including the declaration of Impl brings in new headers that I would have liked to keep separate.

What am I missing?  What do folks put in an Impl declaration and where?  Am I doing the Help dtor wrong?  Argh!

  [1]: https://stackoverflow.com/questions/6012157/does-stdunique-ptrt-requires-to-know-the-full-t-definition


How do I use unique_ptr for pimpl?

Should I use

    std::sort(numbers.begin(), numbers.end(), std::greater&lt;int&gt;());

or

    std::sort(numbers.rbegin(), numbers.rend());   // note: reverse iterators

to sort a vector in descending order? Are there any benefits or drawbacks with one approach or the other?

Sorting a vector in descending order

Whats the difference between std::function&lt;&gt; and a standard function pointer?

that is:

    typedef std::function&lt;int(int)&gt; FUNCTION;
    typedef int (*fn)(int);

Are they effectively the same thing?

Difference between std::function&lt;&gt; and a standard function pointer?

I&#39;ve got some example Python code that I need to mimic in C++. I do not require any specific solution (such as co-routine based yield solutions, although they would be acceptable answers as well), I simply need to reproduce the semantics in some manner.

Python
------

This is a basic sequence generator, clearly too large to store a materialized version.

    def pair_sequence():
        for i in range(2**32):
            for j in range(2**32):
                yield (i, j)

The goal is to maintain two instances of the sequence above, and iterate over them in semi-lockstep, but in chunks. In the example below the `first_pass` uses the sequence of pairs to initialize the buffer, and the `second_pass` regenerates the *same exact sequence* and processes the buffer again.

    def run():
        seq1 = pair_sequence()
        seq2 = pair_sequence()

        buffer = [0] * 1000
        first_pass(seq1, buffer)
        second_pass(seq2, buffer)
        ... repeat ...

C++
---

The only thing I can find for a solution in C++ is to mimic `yield` with C++ coroutines, but I haven&#39;t found any good reference on how to do this. I&#39;m also interested in alternative (non general) solutions for this problem. I do not have enough memory budget to keep a copy of the sequence between passes.

Equivalent C++ to Python generator pattern

How can I check if a `std::thread` is still running (in a platform independent way)?
It lacks a `timed_join()` method and `joinable()` is not meant for that.

I thought of locking a mutex with a `std::lock_guard` in the thread and using the `try_lock()` method of the mutex to determine if it is still locked (the thread is running), but it seems unnecessarily complex to me.

Do you know a more elegant method?

**Update:** To be clear: I want to check if the thread cleanly exited or not. A &#39;hanging&#39; thread is considered running for this purpose.

How to check if a std::thread is still running?

We are having some trouble designing our multi-threaded Entity Framework driven application and would like some guidance. We are creating entities on different threads, the entities are added to collections which are then data-bound to various WPF controls. The ObjectContext class is not thread-safe, so managing this we have essentially have 2 solutions:

Solution 1 has a single context and carefully use locking to ensure no 2 threads access it at the same time. This would be relatively simple to implement but would require the context to be alive for the duration of the application. Is it a bad idea to have a single context instance open like this?

Solution 2 is to create context objects on-demand and then detach the objects immediately, then hold them in our own collections, then re-attach them to do any updating. This has some serious problems for use though, as when the objects are detached they lose references to the navigation property objects. Also there is the problem that 2 threads could still try to access a single object, and both try to attach() it to a context. Also, we would need to supply a new context every time we wanted to access entities&#39; navigation properties.

Q: Are either of the two solutions valid, if not how do you recommend we tackle this?

Entity Framework and Multi threading

**As of 15/2/2012 I have yet to find a good explanation to nor a reason why this does not work. The closest to a solution is to use the traditional [Thread](https://stackoverflow.com/a/4085140/1107464/) approach, but then why include a class that does not (seem to) work in the Android SDK?**

Evenin&#39; SO!

I have an AsyncTask subclass:

    // ParseListener had a callback which was called when an item was parsed in a
    // RSS-xml, but as stated further down it is not used at all right now.
    private class xmlAsync extends AsyncTask&lt;String, RSSItem, Void&gt; implements ParseListener

That is executed like this:

    xmlAsync xmlThread = new xmlAsync();
			
    xmlThread.execute(&quot;http://www.nothing.com&quot;);

Now this subclass has run into a little error. Previously it did some xml-parsing, but when I noticed that it&#39;s **doInBackground()** wasn&#39;t called I stripped it down, line by line, finally ending up with just this:

    @Override
    protected Void doInBackground(String... params) 
    {
	    Log.v(TAG, &quot;doInBackground&quot;);
            return null;
    }

Which, for some reason, logged nothing. However, I added this:

    @Override
    protected void onPreExecute() 
    {
    		Log.v(TAG, &quot;onPreExecute&quot;);
    		super.onPreExecute();
    }

And that line is indeed logged when executing the thread. **_So somehow onPreExecute() is called but not doInBackground()_**. I have another AsyncTask running in the background at the same time which works just fine.

I&#39;m currently running the app on an emulator, SDK Version 15, Eclipse, Mac OS X 10.7.2, close to the North Pole.

**EDIT:**

    @Override
		protected void onProgressUpdate(RSSItem... values) {

			if(values[0] == null)
			{
                                // activity function which merely creates a dialog
				showInputError();
			}
			else
			{

				Log.v(TAG, &quot;adding &quot;+values[0].toString());
				_tableManager.addRSSItem(values[0]);
			}
			
			
			super.onProgressUpdate(values);
		}

_tableManager.addRSSItem() more or less adds a row to a SQLiteDatabase, initialized with the activity&#39;s context. publishProgress() is called by the Interface ParseListener&#39;s callback. However, since I don&#39;t even do anything except log.v in doInBackground() I first found this unnecessary to even bring up.

**EDIT 2:**

Alright, just to be perfectly clear, this is the other AsyncTask, executing in the same activity and working perfectly fine.

    private class dbAsync extends AsyncTask&lt;Void, RSSItem, Void&gt;
    {
    	Integer prevCount;
    	boolean run;
    	
    	@Override
    	protected void onPreExecute() {
    		run = true;
    		super.onPreExecute();
    	}
    	
    	@Override
    	protected Void doInBackground(Void... params) {
    		// TODO Auto-generated method stub
    		run = true;
    		prevCount = 0;
    		
    		while(run)
    		{
    			ArrayList&lt;RSSItem&gt; items = _tableManager.getAllItems();
    			
    			if(items != null)
    			{
    				if(items.size() &gt; prevCount)
        			{
        				Log.v(&quot;db Thread&quot;, &quot;Found new item(s)!&quot;);
        				prevCount = items.size();
        				
        				RSSItem[] itemsArray = new RSSItem[items.size()];
        				
        				publishProgress(items.toArray(itemsArray));
        			}
    			}    			
    			
    			SystemClock.sleep(5000);
    		}
    		
    		return null;
    	}
    	
    	@Override
    	protected void onProgressUpdate(RSSItem... values) {
    		
    		ArrayList&lt;RSSItem&gt; list = new ArrayList&lt;RSSItem&gt;();
    		
    		for(int i = 0; i &lt; values.length; i++)
    		{
    			list.add(i, values[i]);
    		}
    		
    		setItemsAndUpdateList(list);
    		
    		super.onProgressUpdate(values);
    	}
    	
    	@Override
    	protected void onCancelled() {
    		run = false;
    		
    		super.onCancelled();
    	}
    }

**EDIT 3:**

Sigh, sorry I&#39;m bad at asking questions. But here is the initialization of the Tasks.

    xmlAsync _xmlParseThread;
    dbAsync _dbLookup;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    
    _dbLookup = new dbAsync();
    _dbLookup.execute();
    
    _xmlParseThread = new xmlAsync();		
    _xmlParseThread.execute(&quot;http://www.nothing.com&quot;, null);
    }

Android SDK AsyncTask doInBackground not running (subclass)

I have a method with a `HandlerThread`. A value gets changed inside the `Thread` and I&#39;d like to return it to the `test()` method. Is there a way to do this?
 
    public void test()
    {	
    	Thread uiThread = new HandlerThread(&quot;UIHandler&quot;){
    		public synchronized void run(){
    			int value; 
                value = 2; //To be returned to test()
            }
        };
        uiThread.start();
    }
    		
     

Returning value from Thread

What is difference between the below

    ThreadPool.QueueUserWorkItem

vs

    Task.Factory.StartNew

If the above code is called 500 times for some long running task, does it mean all the thread pool threads will be taken up?

Or will TPL (2nd option) be smart enough to just take up threads less or equal to number of processors?

ThreadPool.QueueUserWorkItem vs Task.Factory.StartNew

Suppose I have an unordered set

    unordered_set&lt;int&gt; my_set;
    myset.insert(1);
    myset.insert(2);
    myset.insert(3);

How do I iterate through it? I don&#39;t need to iterate in any order - just as long as I reach each element once. I tried

    for (int i = 0; i &lt; my_set.size(); i++)
         cout &lt;&lt; my_set[i];

to no avail.

How does one iterate through an unordered set in C++?

I&#39;ve got a small problem caused by insufficient documentation of C++11.

I&#39;d like to obtain a time since epoch in milliseconds, or nanoseconds or seconds and then I will have to &quot;cast&quot; this value to another resolution.
I can do it using gettimeofday() but it will be to easy, so I tried to achieve it using std::chrono.

I tried:

    std::chrono::time_point&lt;std::chrono::system_clock&gt; now = 
        std::chrono::system_clock::now();

But I have no idea what is a resolution of obtained in this way time_point, and I don&#39;t know how to get this time as a simple unsigned long long, and I haven&#39;t any conception how to cast it to another resolution.


C++ chrono system time in milliseconds, time operations

I&#39;m sure mutex isn&#39;t enough that&#39;s the reason the concept of condition variables exist; but it beats me and I&#39;m not able to convince myself with a concrete scenario when a condition variable is essential.

https://stackoverflow.com/questions/1055398/differences-between-conditional-variables-mutexes-and-locks question&#39;s accepted answer says that a condition variable is a 

&gt; lock with a &quot;signaling&quot; mechanism. It is used when threads need to
&gt; wait for a resource to become available. A thread can &quot;wait&quot; on a CV
&gt; and then the resource producer can &quot;signal&quot; the variable, in which
&gt; case the threads who wait for the CV get notified and can continue
&gt; execution

Where I get confused is that, a thread can wait on a mutex too, and when it gets signalled, is simply means the variable is now available, why would I need a condition variable?

P.S.: Also, a mutex is required to guard the condition variable anyway, when makes my vision more askew towards not seeing condition variable&#39;s purpose.

When is a condition variable needed, isn&#39;t a mutex enough?

A project I&#39;m working on uses multiple threads to do work on a collection of files. Each thread can add files to the list of files to be processed, so I put together (what I thought was) a thread-safe queue. Relevant portions follow:

    // qMutex is a std::mutex intended to guard the queue
    // populatedNotifier is a std::condition_variable intended to
    //                   notify waiting threads of a new item in the queue
    
    void FileQueue::enqueue(std::string&amp;&amp; filename)
    {
    	std::lock_guard&lt;std::mutex&gt; lock(qMutex);
    	q.push(std::move(filename));
    
    	// Notify anyone waiting for additional files that more have arrived
    	populatedNotifier.notify_one();
    }
    
    std::string FileQueue::dequeue(const std::chrono::milliseconds&amp; timeout)
    {
    	std::unique_lock&lt;std::mutex&gt; lock(qMutex);
    	if (q.empty()) {
    		if (populatedNotifier.wait_for(lock, timeout) == std::cv_status::no_timeout) {
    			std::string ret = q.front();
    			q.pop();
    			return ret;
    		}
    		else {
    			return std::string();
    		}
    	}
    	else {
    		std::string ret = q.front();
    		q.pop();
    		return ret;
    	}
    }

However, I am occasionally segfaulting inside the `if (...wait_for(lock, timeout) == std::cv_status::no_timeout) { }` block, and inspection in gdb indicates that the segfaults are occurring because the queue is empty. How is this possible? It was my understanding that `wait_for` only returns `cv_status::no_timeout` when it has been notified, and this should only happen after `FileQueue::enqueue` has just pushed a new item to the queue.

C++11 thread-safe queue

I am a bit confused about the use of `std::condition_variable`. I understand I have to create a `unique_lock` on a `mutex` before calling `condition_variable.wait()`. What I cannot find is whether I should also acquire a unique lock before calling `notify_one()` or `notify_all()`.

Examples on [cppreference.com](http://cppreference.com) are conflicting. For example, the [notify_one page][1] gives this example:

    #include &lt;iostream&gt;
    #include &lt;condition_variable&gt;
    #include &lt;thread&gt;
    #include &lt;chrono&gt;
     
    std::condition_variable cv;
    std::mutex cv_m;
    int i = 0;
    bool done = false;
     
    void waits()
    {
        std::unique_lock&lt;std::mutex&gt; lk(cv_m);
        std::cout &lt;&lt; &quot;Waiting... \n&quot;;
        cv.wait(lk, []{return i == 1;});
        std::cout &lt;&lt; &quot;...finished waiting. i == 1\n&quot;;
        done = true;
    }
     
    void signals()
    {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout &lt;&lt; &quot;Notifying...\n&quot;;
        cv.notify_one();
     
        std::unique_lock&lt;std::mutex&gt; lk(cv_m);
        i = 1;
        while (!done) {
            lk.unlock();
            std::this_thread::sleep_for(std::chrono::seconds(1));
            lk.lock();
            std::cerr &lt;&lt; &quot;Notifying again...\n&quot;;
            cv.notify_one();
        }
    }
     
    int main()
    {
        std::thread t1(waits), t2(signals);
        t1.join(); t2.join();
    }

Here the lock is not acquired for the first `notify_one()`, but is acquired for the second `notify_one()`. Looking though other pages with examples I see different things, mostly not acquiring the lock.

- Can I choose myself to lock the mutex before calling `notify_one()`, and why would I choose to lock it?
- In the example given, why is there no lock for the first `notify_one()`, but there is for subsequent calls. Is this example wrong or is there some rationale?

  [1]: http://en.cppreference.com/w/cpp/thread/condition_variable/notify_one

Content Type	Original Author	Original Content on Stackoverflow
Question	Yun Huang	View Question on Stackoverflow
Solution 1 - C++	GManNickG	View Answer on Stackoverflow

What's the difference between notify_all() and notify_one() of std::condition_variable?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

What Is the Difference Between POS Tagging and Shallow Parsing?

Android NDK java.lang.UnsatisfiedLinkError: findLibrary returned null

Attributions