Generally, the backtrace is used to get the stack of the current thread, but if there is a necessity to get the stack trace of all the threads, use the following command.

    thread apply all bt


&gt; Is there a command that does?

    thread apply all where

When debugging with several threads, it is also useful to switch to a particular thread number and get the backtrace for that thread only.

From the GNU GDB threads [documentation](https://ftp.gnu.org/old-gnu/Manuals/gdb/html_node/gdb_24.html)
&gt; For debugging purposes, GDB associates its own thread number--a small integer assigned in thread-creation order--with each thread in your program.

Usage:
```
info threads
```
Then identify the thread that you want to look at.
```
thread &lt;thread_id&gt;
```
Finally, use backtrace for just that thread:
```
bt
```

If your process is running:

```
pstack $pid
```

I have a basic number for loop which increments the variable num by 1 over each iteration...

    for (( num=1; num&lt;=5; num++ ))
    do
     echo $num
    done

Which outputs:

    1
    2
    3
    4
    5

I&#39;m trying to make it produce the output (add leading zero before $num):

    01
    02
    03
    04
    05

Without doing:

    echo 0$num

How to add leading zeros for for-loop in shell?

Chrome browser by default is blocking mixed content. How do I adjust my settings/configuration to allow mixed content without making any adjustments on the UI every time?

I have found two solutions but neither of them work:

 1. Several articles say you can adjust this under the Security section
    of &quot;Under the Hood&quot; in the Options. This option no longer seems to
    exist. There is no Under The Hood tab and there is no such dropdown
    to adjust how Chrome handles mixed content as far as I can tell.
 2. Another option is to add the `--allow-running-insecure-content` flag
    to your command line. I did this like so:  `&quot;C:\Program
    Files\Google\Chrome\Application\chrome.exe&quot;
    --allow-running-insecure-content`.  However this made no difference. If I tried adding the flag inside the double quotes, then Windows
    complains saying it is invalid.

So what option do I have now with the latest version of Chrome?

How to get Chrome to allow mixed content?

Is there an equivalent command in GDB to that of WinDbg&#39;s `!process 0 7`?

I want to extract all the threads in a dump file along with their backtraces in GDB. `info threads` doesn&#39;t output the stack traces. So, is there a command that does?


How do I get the backtrace for all the threads in GDB?

<p>Is there an equivalent command in GDB to that of WinDbg's <code>!process 0 7</code>?</p>
<p>I want to extract all the threads in a dump file along with their backtraces in GDB. <code>info threads</code> doesn't output the stack traces. So, is there a command that does?</p>


TL;DR: Please just go to the last part and tell me how you would solve this problem.

I&#39;ve begun using Go this morning coming from Python. I want to call a closed-source executable from Go several times, with a *bit* of concurrency, with different command line arguments. My resulting code is working just well but I&#39;d like to get your input in order to improve it. Since I&#39;m at an early learning stage, I&#39;ll also explain my workflow.

For the sake of simplicity, assume here that this &quot;external closed-source program&quot; is `zenity`, a Linux command line tool that can display graphical message boxes from the command line.

## Calling an executable file from Go


So, in Go, I would go like this:

    package main
    import &quot;os/exec&quot;
    func main() {
        cmd := exec.Command(&quot;zenity&quot;, &quot;--info&quot;, &quot;--text=&#39;Hello World&#39;&quot;)
        cmd.Run()
    }

This should be working just right. Note that `.Run()` is a functional equivalent to `.Start()` followed by `.Wait()`. This is great, but if I wanted to execute this program just once, the whole programming stuff would not be worth it. So let&#39;s just do that multiple times.

## Calling an executable multiple times

Now that I had this working, I&#39;d like to call my program multiple times, with custom command line arguments (here just `i` for the sake of simplicity).

    package main    
    import (
        &quot;os/exec&quot;
        &quot;strconv&quot;
    )

    func main() {
        NumEl := 8 // Number of times the external program is called
        for i:=0; i&lt;NumEl; i++ {
            cmd := exec.Command(&quot;zenity&quot;, &quot;--info&quot;, &quot;--text=&#39;Hello from iteration n.&quot; + strconv.Itoa(i) + &quot;&#39;&quot;)
            cmd.Run()
        }
    }

Ok, we did it! But I still can&#39;t see the advantage of Go over Python … This piece of code is actually executed in a serial fashion. I have a multiple-core CPU and I&#39;d like to take advantage of it. So let&#39;s add some concurrency with goroutines.

## Goroutines, or a way to make my program parallel

### a) First attempt: just add &quot;go&quot;s everywhere

Let&#39;s rewrite our code to make things easier to call and reuse and add the famous `go` keyword:

    package main
    import (
        &quot;os/exec&quot;
        &quot;strconv&quot;
    )

    func main() {
        NumEl := 8 
        for i:=0; i&lt;NumEl; i++ {
            go callProg(i)  // &lt;--- There!
        }
    }
    
    func callProg(i int) {
        cmd := exec.Command(&quot;zenity&quot;, &quot;--info&quot;, &quot;--text=&#39;Hello from iteration n.&quot; + strconv.Itoa(i) + &quot;&#39;&quot;)
        cmd.Run()
    }

Nothing! What is the problem? All the goroutines are executed at once. I don&#39;t really know why zenity is not executed but AFAIK, the Go program exited before the zenity external program could even be initialized. This was confirmed by the use of `time.Sleep`: waiting for a couple of seconds was enough to let the 8 instance of zenity launch themselves. I don&#39;t know if this can be considered a bug though.

To make it worse, the real program I&#39;d actually like to call takes a while to execute itself. If I execute 8 instances of this program in parallel on my 4-core CPU, it&#39;s gonna waste some time doing a lot of context switching … I don&#39;t know how plain Go goroutines behave, but `exec.Command` **will** launch zenity 8 times in 8 different threads. To make it even worse, I want to execute this program more than 100,000 times. Doing all of that at once in goroutines won&#39;t be efficient at all. Still, I&#39;d like to leverage my 4-core CPU!

### b) Second attempt: use pools of goroutines

The online resources tend to recommend the use of `sync.WaitGroup` for this kind of work. The problem with that approach is that you are basically working with batches of goroutines: if I create of WaitGroup of 4 members, the Go program will wait for *all* the 4 external programs to finish before calling a new batch of 4 programs. This is not efficient: CPU is wasted, once again.

Some other resources recommended the use of a buffered channel to do the work:

    package main
    import (
        &quot;os/exec&quot;
        &quot;strconv&quot;
    )

    func main() {
        NumEl := 8               // Number of times the external program is called
        NumCore := 4             // Number of available cores
        c := make(chan bool, NumCore - 1) 
        for i:=0; i&lt;NumEl; i++ {
            go callProg(i, c)
            c &lt;- true            // At the NumCoreth iteration, c is blocking   
        }
    }
    
    func callProg(i int, c chan bool) {
        defer func () {&lt;- c}()
        cmd := exec.Command(&quot;zenity&quot;, &quot;--info&quot;, &quot;--text=&#39;Hello from iteration n.&quot; + strconv.Itoa(i) + &quot;&#39;&quot;)
        cmd.Run()
    }

This seems ugly. Channels were not intended for this purpose: I&#39;m exploiting a side-effect. I love the concept of `defer` but I hate having to declare a function (even a lambda) to pop a value out of the dummy channel that I created. Oh, and of course, using a dummy channel is, by itself, ugly.



### c) Third attempt: die when all the children are dead

Now we are nearly finished. I have just to take into account yet another side effect: the Go program closes before all the zenity pop-ups are closed. This is because when the loop is finised (at the 8th iteration), nothing prevents the program from finishing. This time, `sync.WaitGroup` will be useful.

    package main
    import (
        &quot;os/exec&quot;
        &quot;strconv&quot;
        &quot;sync&quot;
    )

    func main() {
        NumEl := 8               // Number of times the external program is called
        NumCore := 4             // Number of available cores
        c := make(chan bool, NumCore - 1) 
        wg := new(sync.WaitGroup)
        wg.Add(NumEl)            // Set the number of goroutines to (0 + NumEl)
        for i:=0; i&lt;NumEl; i++ {
            go callProg(i, c, wg)
            c &lt;- true            // At the NumCoreth iteration, c is blocking   
        }
        wg.Wait() // Wait for all the children to die
        close(c)
    }
    
    func callProg(i int, c chan bool, wg *sync.WaitGroup) {
        defer func () {
            &lt;- c
            wg.Done() // Decrease the number of alive goroutines
        }()
        cmd := exec.Command(&quot;zenity&quot;, &quot;--info&quot;, &quot;--text=&#39;Hello from iteration n.&quot; + strconv.Itoa(i) + &quot;&#39;&quot;)
        cmd.Run()
    }

Done.

## My questions

- **Do you know any other proper way to limit the number of goroutines executed at once?**

I don&#39;t mean threads; how Go manages goroutines internally is not relevant. I really mean limiting the number of goroutines launched at once: `exec.Command` creates a new thread each time it is called, so I should control the number of time it is called. 

- **Does that code look fine to you?**
- **Do you know how to avoid the use of a dummy channel in that case?**

I can&#39;t convince myself that such dummy channels are the way to go.

How would you define a pool of goroutines to be executed at once?

What is the difference between

    ExecutorService eService = Executors.newFixedThreadPool(2);
    eService.execute(new TestThread6());
    eService.execute(new TestThread6());
    eService.execute(new TestThread6());
    eService.awaitTermination(1, TimeUnit.NANOSECONDS);
    eService.shutdown();

and

    eService.shutdown();
    eService.awaitTermination(1, TimeUnit.NANOSECONDS);


I don&#39;t really understand `shutdown()`. This method does not wait for previously submitted tasks to complete execution. Does it mean `shutdown()` may terminate the tasks which have been submitted, but not completed? I tried some examples, they do not prove it, please give me an example. 


shutdown and awaitTermination which first call have any difference?

I know that compound operations such as `i++` are not thread safe as they involve *multiple* operations. 

But is checking the reference with itself a thread safe operation?

    a != a //is this thread-safe

I tried to program this and use multiple threads but it didn&#39;t fail. I guess I could not simulate race on my machine.

EDIT:
-----

    public class TestThreadSafety {
    	private Object a = new Object();
    	
    	public static void main(String[] args) {
    	
    		final TestThreadSafety instance = new TestThreadSafety();
    		
    		Thread testingReferenceThread = new Thread(new Runnable() {
    
    			@Override
    			public void run() {
    				long countOfIterations = 0L;
    				while(true){
    					boolean flag = instance.a != instance.a;
    					if(flag)
    						System.out.println(countOfIterations + &quot;:&quot; + flag);
    					
    					countOfIterations++;
    				}
    			}
    		});
    		
    		Thread updatingReferenceThread = new Thread(new Runnable() {
    
    			@Override
    			public void run() {
    				while(true){
    					instance.a = new Object();
    				}
    			}
    		});
    
    		testingReferenceThread.start();
    		updatingReferenceThread.start();
    	}
    
    }

This is the program that I am using to test the thread-safety.

Weird behavior
--------------

As my program starts between some iterations I get the output flag value, which means that the reference `!=` check fails on the same reference. BUT after some iterations the output becomes constant value `false` and then executing the program for a long long time does not generate a single `true` output.

As the output suggests after some n (not fixed) iterations the output seems to be constant value and does not change. 

**Output:**

For some iterations:

    1494:true
    1495:true
    1496:true
    19970:true
    19972:true
    19974:true
    //after this there is not a single instance when the condition becomes true
     


Is the != check thread safe?

(edit:  Perhaps I am wrong in what this error means.  Is this indicating that the connection pool at my CLIENT is full?  or a connection pool at the SERVER is full and this is the error my client is being given?)

I am attempting to make a large number of &lt;code&gt;http&lt;/code&gt; requests concurrently using the python &lt;code&gt;threading&lt;/code&gt; and &lt;code&gt;requests&lt;/code&gt; module.  I am seeing this error in logs: 

    WARNING:requests.packages.urllib3.connectionpool:HttpConnectionPool is full, discarding connection:


What can I do to increase the size of the connection pool for requests?

Change the connection pool size for Python&#39;s &quot;requests&quot; module when in Threading

I&#39;m confused in `join()` method used in Threads in Java. In the following code:

    // Using join() to wait for threads to finish.
    class NewThread implements Runnable {

        String name; // name of thread
        Thread t;

        NewThread(String threadname) {
            name = threadname;
            t = new Thread(this, name);
            System.out.println(&quot;New thread: &quot; + t);
            t.start(); // Start the thread
        }
    // This is the entry point for thread.

        public void run() {
            try {
                for (int i = 5; i &gt; 0; i--) {
                    System.out.println(name + &quot;: &quot; + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                System.out.println(name + &quot; interrupted.&quot;);
            }
            System.out.println(name + &quot; exiting.&quot;);
        }
    }

    class DemoJoin {

        public static void main(String args[]) {
            NewThread ob1 = new NewThread(&quot;One&quot;);
            NewThread ob2 = new NewThread(&quot;Two&quot;);
            NewThread ob3 = new NewThread(&quot;Three&quot;);
            System.out.println(&quot;Thread One is alive: &quot;
                    + ob1.t.isAlive());
            System.out.println(&quot;Thread Two is alive: &quot;
                    + ob2.t.isAlive());
            System.out.println(&quot;Thread Three is alive: &quot;
                    + ob3.t.isAlive());
    // wait for threads to finish
            try {
                System.out.println(&quot;Waiting for threads to finish.&quot;);
                ob1.t.join();
                ob2.t.join();
                ob3.t.join();
            } catch (InterruptedException e) {
                System.out.println(&quot;Main thread Interrupted&quot;);
            }
            System.out.println(&quot;Thread One is alive: &quot;
                    + ob1.t.isAlive());
            System.out.println(&quot;Thread Two is alive: &quot;
                    + ob2.t.isAlive());
            System.out.println(&quot;Thread Three is alive: &quot;
                    + ob3.t.isAlive());
            System.out.println(&quot;Main thread exiting.&quot;);
        }
    }

Sample output from this program is shown here:

    New thread: Thread[One,5,main]
    New thread: Thread[Two,5,main]
    New thread: Thread[Three,5,main]
    Thread One is alive: true
    Thread Two is alive: true
    Thread Three is alive: true
    Waiting for threads to finish.
    One: 5
    Two: 5
    Three: 5
    One: 4
    Two: 4
    Three: 4
    One: 3
    Two: 3
    Three: 3
    One: 2
    Two: 2
    Three: 2
    One: 1
    Two: 1
    Three: 1
    Two exiting.
    Three exiting.
    One exiting.
    Thread One is alive: false
    Thread Two is alive: false
    Thread Three is alive: false
    Main thread Exiting

In the above code :

1. I&#39;m not able to understand the flow of execution of the program, And when `ob1` is created then the constructor is called where  `t.start()` is written but still `run()` method is not executed rather `main()` method continues execution. So why is this happening?

2. `join()` method is used to wait until the thread on which it is called does not terminates, but here in output we see alternate outputs of the thread why??

And if the use of `join` is this then what is the use of `synchronized`??

I know I&#39;m missing a basic concept here, but I&#39;m not able to figure it out so please help.

Java Multithreading concept and join() method

is there a way in Visual Studio to use a custom Configuration like &quot;#if DEBUG&quot;

I need a &quot;#if OFFLINE&quot; as my Build-Config&#39;s name is &quot;Offline&quot; (only for further debug-purposes too)...

Thanks!

#if debug --&gt; #if myOwnConfig?

When launching an app from a URL, there is a distinction between whether the URL is freshly launching an app, or if it&#39;s resuming an app that has been put into a suspended state.

My question is, how do I debug the process of a &quot;fresh launch&quot; *from* a URL? Hitting &quot;Run&quot; in Xcode automatically opens the app. Then, I have to suspend the app to reach Safari and access my test site. But if I close my suspended app, Xcode is no longer attached to it and I&#39;m unable to debug.

iOS: How to debug &quot;freshly launching&quot; an app from a URL


I am working on a proof of concept using Angular JavaScript.

How to debug the Angular JavaScript code in different browsers (Firefox and Chrome) ?


How to debug Angular JavaScript Code

I&#39;m trying to investigate a bug in a crash dump (so I can not change the code).
I have a really complicated object (thousands of lines in the serialized representation) and its state is inconsistent. To investigate its state the Visual Studio debugger view is useless. But the object has a data contract. I&#39;d like to serialize it and then use my favorite text editor to navigate across the object. Is it possible to do the from the debugger?

Visual Studio how to serialize object from debugger

We have a button. Click events are handled by a 3rd party framework, however, the framework is buggy somehow.

We want to debug the framework, however, we don&#39;t know where the corresponding event handler code resides to set a breakpoint. How to generally &quot;break on next click event&quot; and see where and how this click is handled by the 3rd party framework?

Chrome debugging - break on next click event

I&#39;m under osx 10.8.4 and have installed gdb 7.5.1 with homebrew (motivation get a new gdb with  new features such as --with-python etc... )

Long story short when I run debug within a c++ Eclipse project I get :


    Error in final launch sequence
    Failed to execute MI command:
    -exec-run
    Error message from debugger back end:
    Unable to find Mach task port for process-id 46234: (os/kern) failure (0x5).
     (please check gdb is codesigned - see taskgated(8))
    Unable to find Mach task port for process-id 46234: (os/kern) failure (0x5).
     (please check gdb is codesigned - see taskgated(8))

I have followed various suggestions for code signing

- https://sourceware.org/gdb/wiki/BuildingOnDarwin
- partly http://www.noktec.be/archives/1251 with various adjusts

So I did:

1. Set up the certificate
2. Sign the gdb -&gt; codesign -s gdb-cert /usr/local/bin/gdb

When I re-run debugging in Eclipse I get same error as above &quot;(please check gdb is codesigned - see taskgated(8))&quot;.

If I set back the gdb to the older gdb (in the gdb preferences of Eclipse) /usr/libexec/gdb/gdb-i386-apple-darwin the debugging runs as expected.

Any solutions / hints out there ?

Thx

Pelle

&quot;please check gdb is codesigned - see taskgated(8)&quot; - How to get gdb installed with homebrew code signed?

I&#39;m trying to attach a program with gdb but it returns:

&gt; Attaching to process 29139  
&gt;     Could not attach to process.  If your uid matches the uid of the target
&gt;     process, check the setting of /proc/sys/kernel/yama/ptrace_scope, or try
&gt;     again as the root user.  For more details, see /etc/sysctl.d/10-ptrace.conf  
&gt;     ptrace: Operation not permitted.

gdb-debugger returns &quot;Failed to attach to process, please check privileges and try again.&quot;

strace returns &quot;attach: ptrace(PTRACE_ATTACH, ...): Operation not permitted&quot;

I changed &quot;kernel.yama.ptrace_scope&quot; 1 to 0 and `/proc/sys/kernel/yama/ptrace_scope` 1 to 0 and tried `set environment LD_PRELOAD=./ptrace.so` with this:

    #include &lt;stdio.h&gt;
    int ptrace(int i, int j, int k, int l) {
        printf(&quot; ptrace(%i, %i, %i, %i), returning -1\n&quot;, i, j, k, l);
        return 0;
    }

But it still returns the same error. How can I attach it to debuggers?

How to solve &quot;ptrace operation not permitted&quot; when trying to attach GDB to a process?

I went to use GDB in OS X v10.9 (Mavericks), and it&#39;s not there. Where has it gone?

    # /usr/lib/gdb
    -bash: /usr/bin/gdb: No such file or directory
    # gdb
    -bash: gdb: command not found

I also launched Xcode 5.0.1:

&gt; Preferences &gt; Downloads

..and there&#39;s no longer command line tools available — ffs!


GDB missing in OS X v10.9 (Mavericks)

(Preface: I&#39;m pretty new to C/C++ and I don&#39;t really know how debugging in native code actually works.)

Some sources say that gdb and lldb can debug [any program compiled to machine code](http://www.lego.com/en-us/mindstorms/products/fan-made-bonus-robots/ev3meg). Others say that to debug with gdb you **must** compile in gcc [with the `-g` flag](http://tedlab.mit.edu/~dr/gdbintro.html). The documentation for gcc itself suggests this is optional, and that in fact if you use it, it can cause problems for debuggers _other than_ gdb. Clang also has a `-g` flag and the documentation basically just says &quot;Generate debug information.&quot;

So are these debuggers restricted to their own toolchains (GNU and LLVM), or are they somehow independent of the compiler used?

Is it possible to debug a gcc-compiled program using lldb, or debug a clang-compiled program using gdb?

New to the project, have multiple source files used for compilation and some &quot;could&quot; be dynamic libraries, loaded at runtime. When debugging the executable using &quot;GDB&quot;, is there a command to list all the source files (static) used to build the executable. Once I have all the source files, it&#39;s easy for me to set breakpoints, list functions etc. I couldn&#39;t find a command to do it in GDB (I&#39;m sure there should be one). In DDD (gui based gdb), there is a Menu: File-&gt;List, which lists all the source files used and static libraries used for building the executable. Unfortunately, for command line based debugger (GDB), I couldnt find an equivalent command.

Content Type	Original Author	Original Content on Stackoverflow
Question	srikantha ks	View Question on Stackoverflow
Solution 1 - Multithreading	Sharad	View Answer on Stackoverflow
Solution 2 - Multithreading	Employed Russian	View Answer on Stackoverflow
Solution 3 - Multithreading	diviquery	View Answer on Stackoverflow
Solution 4 - Multithreading	EricRen	View Answer on Stackoverflow

How do I get the backtrace for all the threads in GDB?

Multithreading Problem Overview

Multithreading Solutions

Solution 1 - Multithreading

Solution 2 - Multithreading

Solution 3 - Multithreading

Solution 4 - Multithreading

How to get Chrome to allow mixed content?

How to add leading zeros for for-loop in shell?

Attributions